describe "#match_flight_date?" do
let(:item) { FactoryGirl.build(:avia_commission_item) }
subject { item.match_flight_date?(locations) }
context "when range includes all locations" do
let(:item) { FactoryGirl.build(:avia_commission_item, :flight_date_from => Time.now,
:flight_date_to => 20.days.from_now) }
it { should be_true }
end
context "when range includes only first location" do
let(:item) { FactoryGirl.build(:avia_commission_item, :flight_date_from => Time.now,
:flight_date_to => 7.days.from_now) }
context "and flight_date_match is :first" do
before { item.flight_date_match = :first }
it { should be_true }
end
end
context "when range is empty" do
it { should be_true }
end
end
How to describe your methods
describe 'the authenticate method for User' do
describe 'if the user is an admin' do
describe '.authenticate' do
describe '#admin?' do
Keep your description short
it 'has 422 status code if an unexpected params will be added' do
context 'when not valid' do
it { is_expected.to respond_with 422 }
end
Single expectation test
it { is_expected.to respond_with_content_type(:json) }
it { is_expected.to assign_to(:resource) }
Test all possible edge-cases
describe '#destroy' do
context 'when resource is found' do
it 'responds with 200'
it 'shows the resource'
end
context 'when resource is not found' do
it 'responds with 404'
end
context 'when resource is not owned' do
it 'responds with 404'
end
end
Use subject
it { expect(assigns('message')).to match /it was born in Belville/ }
subject { assigns('message') }
it { is_expected.to match /it was born in Billville/ }
Use let
describe '#type_id' do
before { @resource = FactoryGirl.create :device }
before { @type = Type.find @resource.type_id }
it 'sets the type_id field' do
expect(@resource.type_id).to<EMAIL_ADDRESS>end
end
describe '#type_id' do
let(:resource) { FactoryGirl.create :device }
let(:type) { Type.find resource.type_id }
it 'sets the type_id field' do
expect(resource.type_id).to equal(type.id)
end
end
Mock or not to mock
# simulate a not found resource
context "when not found" do
before { allow(Resource).to receive(:where).with(created_from: params[:id]).and_return(false) }
it { is_expected.to respond_with 404 }
end
Create only the data you need
describe "User" do
describe ".top" do
before { FactoryGirl.create_list(:user, 3) }
it { expect(User.top(2)).to have(2).item }
end
end
Use factories and not fixtures
user = User.create(
name: 'Genoveffa',
surname: 'Piccolina',
city: 'Billyville',
birth: '17 Agoust 1982',
active: true
)
user = FactoryGirl.create :user
describe Admin::ReceiptsController do
before :each do
node = mock_model(Node, :counter => 1, :counter= => 2, :save => true, :has_role? => true,
:name => "name")
Node.should_receive(:find).and_return(node)
Acl.should_receive(:can_access?).and_return(true)
end
describe "receipts_list" do
before :each do
receipt = mock_model(Receipt, :to_admin_struct => Admin::ReceiptStruct::ReceiptItem.new)
Receipt.should_receive(:find).and_return([receipt])
Receipt.should_receive(:count).and_return(1)
end
subject { invoke(:receipts_list, "", 10, 0) }
it { should be_an_instance_of Admin::ReceiptStruct::ReceiptsItemsList }
it "should return a list of receipts items" do
subject[:items].should_not be_empty
end
specify { subject[:items][0].should be_an_instance_of Admin::ReceiptStruct::ReceiptItem }
it "should return a list with count value" do
subject[:count].should == 1
end
end
end


This shebang was unrecognized. ShellCheck only supports sh/bash/dash/ksh. Add a 'shell' directive to specify.
#!/bin/mywrapper
echo "Hello World"
#!/bin/mywrapper
# shellcheck shell=bash
echo "Hello World"
You have specified a shebang that ShellCheck doesn't recognize. This can be due to invoking the script via a wrapper, specifying a dummy like #!/bin/false
to prevent execution, or trying to check a script for a non-Bourne shell or tool.
If this really is a sh/bash/dash/ksh script, please add a shell
directive after the shebang to tell ShellCheck how to interpret the script, as in the example. You can also specify the shell with the -s
flag.
If this is a script in some other language, like #!/bin/sed
for a sed
script, then sorry -- ShellCheck does not support sed
, awk
, expect
scripts. It only supports Bourne style shell scripts.
None.


Random: Japanese YouTuber Spends $20,000 Buying Every Single Product At Nintendo Tokyo
The poor sales assistant...
by Ryan CraddockWe know plenty of people who aren't shy of spending silly amounts of money on Nintendo products, but this takes things to a whole other level.
Popular Japanese YouTuber, Hikakin, shared a new video over the weekend to his 7.82 million subscribers. In the video, he takes a trip to the lovely-looking new Nintendo store in Tokyo, casually grabbing one of every single item available. Wowzers.
This includes stacks of Nintendo Switch games, more plushies than we can count, one of every console variant available, and so much more. Seriously, the video's worth a watch just to see the rows and rows of shopping bags that he has after throwing everything at the poor assistant working on the till.
Feel free to check out the madness below (if you don't have much time, things start getting particularly exciting at around the 16-minute mark). In total, he spent 2,176,758 yen, which equates to roughly $20,000.
If anyone has this kind of money to spend and fancies taking us to Nintendo Tokyo for a shopping spree, we seriously wouldn't mind.
[via youtu.be, gonintendo.com]


We know that biodiversity is changing, and we can identify trends and directions in this change. In some cases we can attribute these to factors such as climate change, agricultural expansion, urbanization or pollution, but the underlying causes of change are rarely clear and simple. Many factors interact to cause the changes we see, and the results may be unpredictable
In order to respond effectively to negative changes, we need to know what causes them. If ecosystem health is declining, what are the most important drivers of that change? How will those drivers interact and manifest themselves over time? Will declines continue to be gradual, or are there tipping points, beyond which irreversible change occurs?
To answer such questions we use sophisticated models to recreate the dynamics and causality of biodiversity change. This enables us to understand where we are now and to extrapolate ahead to the future, in order to predict the likely causes and results of change over time.
The Nereus Project is a nine-year, international research partnership dedicated to developing an interdisciplinary approach towards the promotion of sustainable fisheries. As part of this project, researchers at UNEP-WCMC are using species distribution models to explore the impacts of climate change on marine fish and invertebrates, and seeking to untangle the multitude of ecological, oceanographic, political and socio-economic factors that drive changes in fisheries production. This aims to allow accurate predictions of future yields to be made, on which effective and sustainable management plans can be based.
See also our featured work on the Madingley and PREDICTS models.


This text is in limbo.
One of the badly understood features of modern object oriented programming languages is the importance of exceptions and how to deal with them. In comparison to a complete application, the nominal flow of an application only takes a relatively small part of the development effort. The true development cost of an application is in the code that deals with exceptional conditions. This is especially true for a web application, where the liberties the end-user has, have to be compensated by application code. In essence, in all security sensitive applications, undetermined behavior is the major risk. If we do not deal with exceptional conditions, it means that anything can happen in these conditions, making the application inherently unstable and unsafe. And in web applications, based on the very simple, stateless HTTP protocol, there are so much more exceptional conditions than in a desktop application.
One popular approach to exception handling is to let them all propagate to the final layer, where the user is then presented with an error dialog or an error page. This is surely the cheapest way of dealing with exceptions: the application essentially crashes, and the user is left hanging out to dry. This approach is only acceptable in the most simple of demo applications, to show some nominal functionality quickly (and then you are cheating your audience). Where in desktop application this approach will annoy the user, in web applications, you are potentially creating a security hole and the possibility for corruption of your back-end data. In a web application, the end user will probably use his back-button, and try something else. However, since the previous outcome was unexpected, the application is now in an undetermined state, and we cannot know for sure even how our nominal code will act when called in this state (in practice, the session and application scope is no longer to be trusted). From this example it should be clear that, in many cases, a real crash of the application is often the best possible outcome, to avoid uncontrolled access and data corruption.
Now, if you choose this popular approach of letting all exceptions propagate to the final layer, working with checked exceptions is cumbersome: each method has to declare that it throws the possible exceptions we just want to propagate anyway. So, in this frame of mind, an aversion against checked exceptions comes naturally. Hence, another popular practice has become for frameworks and libraries to use unchecked exceptions (e.g., Spring, the JSF specification and Hibernate 3). As we shall see below, this might be an acceptable approach for some kinds of exceptional conditions, but certainly not for semantic exceptional conditions.
Yet, it is not so hard to deal with exceptions properly. The first step in dealing with exceptions is to understand the different kind of exceptional conditions that can occur during execution of your program. In essence, an exceptional condition is anything that is not explicitly forbidden (precondition) that keeps your code from reaching its nominal effect (post-condition). Calling code in violation of preconditions is not an exceptional condition, but a programming error.
Every method tries to reach its nominal post-condition (which is often not completely deterministic in an environment with dynamic binding like an object oriented programming language). That is its reason for being. During its execution, it might encounter exceptional conditions. When this happens, the method can decide either to work around this condition, and still reach its nominal post-condition, or it can decide to give up. In the first case, the condition actually is not considered exceptional, but part of the normal operational conditions, in which the nominal effect is reached. In the latter case, execution of code should be halted in a controlled fashion. This means that nothing in the state of the program should have changed: it should be as if the method that cannot reach its nominal post-condition, was never called in the first place. The method should be atomic: either it reaches its nominal effect, or it does nothing. Furthermore, the caller of the method should be warned about the success or failure of the method call.
Throwing an exception is the ideal way for a method to signal that it cannot reach its nominal effect as described by the post-condition. After detection of the exceptional condition, nominal execution stops, and the method makes sure that nothing is changed to the overall state of the system (either because the method didn't make a change yet, or because the method rolls back all changes it made). Then, it signals its failure by throwing an exception.
If a method cannot reach its post-condition, and it is impossible for the method to behave in an atomic way, the caller should be aware of this. The calling method itself should be atomic too, and if the called method cannot do this, than the calling method gets the burden. If this is a problem for the calling method too, by unwinding the call stack, we finally reach the main method (or it's equivalent in a web application). Here we have only 1 recourse: quit the application gracefully.
Now, what are the possible reasons why a correctly implemented method, if called in acceptable conditions, i.e., not in violation of its preconditions, cannot reach its nominal post-condition? Here are 2 major types of conditions:
null
.The above examples obviously are based on the premise that network connection stability, network administrator clumsiness and the amount of RAM in the machine are outside the system we are developing. If you consider such occurrences to be within the system, you either do not consider them exceptional, and consequentially have dealt with them in the nominal flow of your code, or you consider the conditions to be of a semantic nature. If not, you have a programming error.
From this, it follows that the main difference between the 2 presented types of conditions is whether they are considered internal or external to the system. Other internal exceptional conditions might have to do with security, or be technical. Other external exceptional conditions might be of semantic nature, e.g., when DB corruption is encountered.
Since we want to signal exceptional conditions using exceptions, it seems like a good idea to introduce different exception classes for these kinds of exceptions. Henceforth we shall speak of internal exceptions and external exceptions, as exceptions that signal issues that are considered to be inside the system, which should be dealt with, or outside the system, which should result in graceful shutdown, respectively. Semantic exceptions are internal exceptions that signal internal exceptional conditions of semantic nature. Technical exceptions signal external exceptional conditions of technical nature, but this distinction will prove rather moot later on.
END OF CONFUSION
Programming errors are not exceptional conditions, not in the
sense that we make mistakes a lot, but in the sense that exceptional
conditions are still expected conditions, and programming
errors are not. Sadly, software requires the programmer to take into
account all possible conditions that can occur during the execution
of his code, exhaustively, for the code to have a chance to be
correct.
Correctness of code is defined as the mathematical
guarantee that, if a method is called within the boundaries set by its
preconditions, all method calls will result in either,
A programming error is anything that (potentially) causes different behavior.
For a method to be able to guarantee
correctness, it must take into account in its implementation all possible
conditions that can occur during execution, that do not violate
preconditions. In other words, all possible conditions must be
exhaustively known, and either be listed in the preconditions as
unacceptable for the method, or be dealt with in the code. The latter can
mean reaching the nominal effect in those conditions, or throwing an
exception.
So, if a method behaves weird when it is called in
violation of its preconditions, this is not a bug in the implementation of
the method. Actually, as method implementors, we don't care about this.
Calling a method in violation of its preconditions is a programming error in
the implementation of the calling method, not of the called method.
The point I'm trying to make is, that if a condition can occur
during execution of a method that was not taken into account either
in the preconditions or in the code, i.e., it is an unexpected
condition, you have made a programming error . Since you
didn't expect the condition, you didn't reason about how your code behaves
when it occurs, and as a consequence the state of the entire system has
become undetermined : we don't know where we are anymore, and
anything we do now will have unpredictable consequences. If you look at it
as having forgotten to list the condition in the method's preconditions, it
is clear that the calling method will be quite surprised, and since it has
no clue what happened, it cannot react.
An unexpected
condition is different from an expected exceptional
condition. We have reasoned about expected conditions,
and
Note that encountering unexpected conditions is not the only kind
of programming error possible. You can, e.g., also blatantly fail to reach
your post-condition, when you typed a -
where a +
was in order. But it is a very important kind of programming error, because
it is very difficult to always be exhaustively aware of all possible
conditions.
Very many unexpected conditions will turn up as
unexpected exceptions in Java, like a NullPointerException
(we
didn't take into account the situation where the parameter is
null
), or an ArithmeticException
(we forgot the
nominator variable could be 0
in a division). But also not
taking into account a possible ExceptionInInitializerError
when
calling java.lang.reflect.Method.invoke()
on a constructor, or
not taking into account a possible SQLException
when executing
a SQL statement using java.sql.Statement.execute()
are
programming errors of the same kind.
Exceptions raised in this fashion should not concern a theory of dealing with exceptions in correct programs. However, as it stands, we do get them for free, and in a modern language like Java or C# much more than in older languages like C, C++ or Delphi. Many programming errors that would go unnoticed at first in older-generation programming languages, at least are signaled immediately in the current generation. This is a very good thing, because the system becomes undefined once we executed the buggy code, and anything we do after that makes things worse, potentially corrupts our data, or opens up security holes. So, while talking about exceptions, it is not a bad thing to take these occurrences into account, and to formulate a strategy for dealing with them.
Consider the fact that it is very hard to always be exhaustively aware of all possible conditions. As humans, we can manage conditions that are considered to be part of the nominal flow of methods we use. Being exhaustively aware of all exceptional conditions for the methods we use, or their preconditions, is much more difficult. Now, in these modern languages, we can define the exceptional conditions (and in some languages even the preconditions, but not in Java) of methods we use, with a language construct of which the compiler is aware. This means that, while we are programming our code, the compiler in the IDE will exhaustively list for us all possible exceptional conditions, and bar us from delivering code that does not explicitly deal with these conditions in some way.
At least, that is, if the exceptional conditions are listed as checked exceptions in the signature of the methods we use. If, for a called method, we exhaustively considered all possible conditions, and we listed exceptional conditions as checked exceptions that the called method can throw (forgetting preconditions for a moment), the compiler will make sure that in the calling method's implementation, we considered all possible conditions for this particular method call. If the method is robust (there are no preconditions), this means that coverage is complete for this one method call, and if this is applied to all code in the calling method's implementation, coverage is indeed complete for the entire method. This computer assistance is an enormous help in trying to get correctness!
With this in mind, maybe you can understand my
aversion against unchecked exceptions. When the methods I use only list
unchecked exceptions, my IDE can't help me in being aware of all possible
conditions, and I must revert to looking things up by hand in Javadoc. The
loss in efficiency is enormous. Given, the IDE only warns me about potential
exceptions. I still need to look up by hand the conditions under which these
exceptions might be thrown (the Javadoc throws
clause), because
that is what I need to consider in my implementation. But still, the aid I
get is enormous when compared to no help at all.
Exceptions raised as the result of a programming error are a mechanism that allow us to efficiently do what is the only thing we can do when these errors do make it to production software: gracefully quit the application a.s.a.p., before more harm is done.
Note that this is the best possible behavior for any sort of programming error, not only when unexpected exceptions occur. Programming errors that result in an unexpected exception feature this behavior naturally. But there is also a large class of programming errors that we might detect ourselves.
A best-practices programming style is to
write down all thoughts about you're algorithm using assert
statements. Programmers will recognize this experience: while coding, now
and then, you sit back and take a look at your method's implementation, and
you reason about it: can this variable be null
here? what does
my implementation do on a Thursday? etcetera. The whole idea behind this
programming style is to immediately take down the result of this short
brainstorm as an assertion. You have just spend some minutes proving to
yourself that this variable can never be null
in this place in
your code: this proves that this knowledge is not trivial. So, it should
surely be documented. Now, rather than writing a //
-comment,
by writing an assert
-clause, you're assumption will also be
put to the test during execution (when assertions are enabled). If the
assertion fails, it means that your reasoning was flawed, and thus that you
have made a programming error. The assert
-mechanism will throw
an exception when this happens, which is exactly the behavior we said above
we'd like.
Now and again, you also encounter the situation where we
might detect a programming error in the flow of the code. E.g., as the
result of a test (an else
-branch that cannot occur in a large
decision tree, or a default
case in a switch
-statement), or as an exception that, according to your reasoning, should
not occur (i.e., an unexpected checked exception, for which you have to
write a catch
-clause anyway). Instead of merely writing a
comment in these cases, it is a good idea to write assert
false;
as the body of this branch or this catch
-clause,
or throw an exception or an error of another kind (the assert
-mechanism doesn't provide for extensive reporting on the error; this is
especially sad when we encounter an unexpected exception, that usually
carries a lot of interesting debug information; on the other hand, the code
for throwing an exception cannot be easily disabled using runtime options,
like assertions).
Finally, an important type of programming errors
is the calling of methods in violation of their preconditions. This kind of
programming error can, sadly, not be checked statically by the compiler, and
also cannot not be checked with unit testing (unit testing can only check
whether post-conditions are reached in a number of test cases, that must
adhere to the preconditions). Again, it is best-practice to take down
preconditions at the start of your method in code, using an
assert
-clause. Any violation of preconditions while calling
methods in the implementation of a method will then be signaled, hopefully
during the test phase of your lifecycle.
With these practices in
place, we know that a large portion of potential programming errors will be
signaled by the occurrence of either an unexpected exception (which only can
be an unchecked exception) or a java.lang.AssertionError
. I
also hypothesize that any other kind of programming error is related to not
reaching the post-condition (including throwing expected exceptions), and
thus in the realm of unit testing.
The above clearly gives the hint
that unchecked exceptions (and java.lang.Error
instances) have
a role to play in the context of programming errors, and that checked
exceptions should be used for all expected exceptions. Since we presume to
write correct software, it does not make sense to foresee programming errors
in the throws-clause of a method signature. Exceptions that signal
programming errors are unexpected in essence. Using checked exceptions for
expected exceptions gives the IDE the opportunity to help us in taking into
account all possible conditions in our algorithm exhaustively.
Now that we have discerned different kinds of exceptions, we need to contemplate what we want to do when they occur.
When a
semantic exception occurs, we want to block the operation and
warn the end user, so that he can change his behavior and continue working
with the program. In my experience, a semantic exception occurs in an
interactive program when the end user provided faulty input or performed an
illegal operation (of course, a really good user interface would prohibit
the user action in these conditions in the first place, but with a classic
web application that is very hard). In a batch program, a semantic exception
would only occur with corrupt or incomplete input. I cannot imagine any
other final reason for a semantic exception then these, but please report
anything I might have missed. In both cases, it is important that the user
gets feedback about what he did wrong, for him to be able to correct his
input or behavior. Also, the same applies for any other kind of
internal exception (e.g., security exceptions) that reaches the
user.
So, in general, we know what to do. In particular, what we need
to tell the user exactly and how, depends on the particular kind of
exception, the exact circumstances in which it occurred, possible i18n
settings, and more.
When a technical exception, or any
other kind of external exception, occurs, there is little we can
do. Since these conditions are, per definition, considered to be outside the
system, we do not want to deal with them (otherwise, we would consider them
part of the system). By placing them outside of the system, we are saying
that we only guarantee correct behavior of our application when they do not
occur. This may sound very much like a precondition, and in fact it is.
These are (often implicit) preconditions for the system as a whole.
When a external exception occurs, we want to inform the user of that fact,
make clear that it has nothing to do with him, but we also want to notify
the persons that are responsible for solving the external problem, a.s.a.p.
The user cannot continue until the problem is fixed, and we exit the
application gracefully, making sure that no harm has been done.
So,
in general, we know what to do. In this case, the message to show to the
user can be very generic. But again, in particular, what we want to tell the
administrator has to be very precise for the particular kind of exception
and the exact circumstances in which it occurred. In this case, view-related
issues, like i18n, are of lesser or no importance.
Again, this is
very much like what we want to do when a programming error occurs, signaled
by an unexpected exception. The main difference between these 3 kinds of
exceptions, expected internal exceptions, expected external exceptions and
unexpected exceptions, is the audience to which they are of interest:
expected internal conditions are of interest to the end-user, expected
external conditions are of interest to the administrator, and unexpected
conditions are of interest to the developer. Sadly, because exceptions
necessarily occur at runtime, the end-user is always confronted with them.
 We apologize to the user, and will correct the situation a.s.a.p.
With a web application, this is relatively easy to do (mail a trouble ticket
to the administrator and show a decent page to the end user). For a desktop
application, this is much more problematic. Either the end-user is the
administrator, and chances are that he doesn't have the ability to correct
the problem, or the administrator is unknown to us.
For unexpected
exceptions, the problem is greater. The developer is one sizable step
further removed from the running application. Mailing a trouble ticket is
feasible, but might be considered a back door by the client, and thus be
barred for security reasons. On Mac OS X, this is solved for desktop
applications by presenting the end-user with a dialog that gives him the
option to mail a trouble ticket to the developers. In a web application, if
mailing the developers is prohibited, we should at least have very good
logging. The same applies to expected external exceptions, of course.
From the above it should be clear that we should have code that, once and for all, implements the general behavior that we want for expected internal exceptions, expected external exceptions, and unexpected exceptions. Furthermore, it should also be clear, that there is little or no difference in dealing with expected external exceptions and unexpected exceptions.
First of all, we need a mechanism to recognize these different kinds of exceptions, so that we can trigger the applicable handling code. Secondly, we need the applicable handling code for the different kinds of exceptions, and it needs to be constructed in such a way that the appropriate particular behavior with respect to the particular kind of exception and the exact circumstances, and view-related issues, is executed in some way.
Obviously, in a modern language such as Java,
the way to recognize the different kinds of exceptions, is to introduce
different exception classes in an inheritance hierarchy, and to use these
types in the catch
-clause to filter them out of all possible
exceptions. Therefor, we define a number of general exception classes in
ppw-exception
:
A {@link be.peopleware.exception_II.ProgrammingError} could be used if an
assert
-clause doesn't carry enough information for debugging
purposes. Furthermore, assert
-functionality is usually disabled
in deployment after an initial acceptance phase for performance reasons.
Therefor, it is sensible to use{@link be.peopleware.exception_II.ProgrammingError} instead to
document branches that should be unreachable (the catch
-clause
of exceptions that shouldn't occur, or else
-branches of decision
trees or default
branches of switch
-statements
that should never be chosen). It would be nice if
AssertionError
would be a subclass of {@link be.peopleware.exception_II.ProgrammingError}, but we cannot change the core API, of course.
Also, the other way around is not feasible, since
AssertionError
doesn't provide a constructor that takes a
Throwable
as an argument, which is important information in
some cases. The user should be aware that the reaction higher up to
this error is probably an immediate shutdown of the application, with a warning to the developer and a note in the log.
An {@link be.peopleware.exception_II.ExternalError} should be used whenever an operation fails
because of expected reasons we decide are outside our system. When you decide to throw this error,
you should know that the reaction higher up probably is to shut down the
system, with a warning to the developer and a note in the log. We have chosen to use an Error
here, because we feel
that code higher up should not be concerned with occurrences like these (we
do consider the occurrence outside the system, remember), unless it is the
code that is specifically handling external errors. The exception thus should
best be unchecked, and by providing a specific exception type for these
occurrences, it becomes easy to detect them at the higher levels, and write
the handling code in a general way. We could also have chosen to make {@link be.peopleware.exception_II.ExternalError} a RuntimeException
(i.e., an unchecked
exception), we we believe the documented semantics of Error
are
closer to our need.
{@link be.peopleware.exception_II.InternalException} is the general super type for all exceptions that signal expected exceptional occurrences that we consider to be internal to the system. These should be dealt with, and to notify the programmer of this during development, this is a checked exception. The difference with other checked exceptions is that, by throwing an {@link be.peopleware.exception_II.InternalException}, we are telling our users that we decided that this occurrence indeed is internal, and should be handled.
Other checked exceptions should be used, in particular by lower level libraries, to signal exceptional occurrences, when the developer of that code does not want to decide whether or not the condition is to be considered internal or external, or a programming error. Take, e.g., a persistence library, that might need to signal that a file is corrupt. Some programs that use the library will consider this problem to be external, but the library can also be used by an application that specifically scans for corrupt files, in which case the condition is obviously internal. The point is, the lower level library is supporting code, and is not in a position to make the call. For reasons explained higher, I strongly believe that such a library should throw checked exceptions, though.
{@link be.peopleware.exception_II.SemanticException} is a subtype of {@link be.peopleware.exception_II.InternalException}, to be used as supertype to signal security related exceptional conditions.
At the moment, there are no general subtypes defined, and this exception has no special properties. This will probably change as the library evolves.
{@link be.peopleware.exception_II.SemanticException} signal that their was a semantic exceptional condition. Most often, this is related to what is more commonly known as validation.
BeanException
CompoundException
NOT RIGHT: HANDLING CODE SHOULD DO THE LOGGING? BUT THEN WE ARE NOT USING THE RIGHT LOG? NOT SURE!
 USING THE CLASSNAME!
Programming errors should
be handled by special handling code, that is triggered by AssertionErrors
and{@link be.peopleware.exception_II.ProgrammingError}, but also by
any other unchecked exception (RuntimeException
) or Error
that reaches the
handling layer. But since a layer handling {@link be.peopleware.exception_II.ExternalError ExternalErrors} should be defined immediately below this layer, and checked exceptions, most
notably {@link be.peopleware.exception_II.InternalException ApplicationExceptions}, are normally dealt with much
earlier, this handling code should handle all Throwables
that
reach this layer. If {@link be.peopleware.exception_II.ExternalError ExternalErrors} or checked exceptions do
reach the handling code, that is a programming error in itself. The handling
code can benefit from getting AssertionErrors
or{@link be.peopleware.exception_II.ProgrammingError}, because they make it possible to give more
precise feedback about the programming error.
The handling should catch the exception, log it, possibly notify the correct audience, and exit the application. The latter can possibly be done most easily by rethrowing the caught exception. LOG LEVEL???
<<<< HERE
http://www.mindview.net/Etc/Discussions/CheckedExceptions
Absence of proof is not proof of absence.
As a side note, now that we are
talking about the audiences for signaling issues, consider compilation
problems. A failed compile is a signal of a programming error to the right
audience, at the right time: the developer, during development. This is the
exact reason why strongly typed, compiled languages are to be preferred over
weakly typed or scripting languages: the compile phase is a validation at
the right time in the right context. Any programming error that can be
determined by an automated, static process is a programming error that will
not make it to the end-user, guaranteed. Programming languages that offer
more development-time validation are inherently better for production
software.
Assertions and unexpected exceptions are merely a stopgap
measure for validation that cannot occur statically at development-time.
Also, the concept of testing is introduced in the software development
lifecycle as a stopgap measure for the same problem: we hope that
programming errors will surface close to the developer, before the product
is shipped, by executing the code under as many conditions as possible, and
comparing the actual results of operations to expected results (an
unexpected exception, by the way, is always a deviation of the expected
result). But note that testing never guarantees correctness, the way formal
static verification does. The absence of failed tests doesn't guarantee the
absence of errors.
Also note that testing implies testing for
expected exceptions too: getting an exception in documented circumstances is
part of the expected behavior, as is the fact that the state of the system
is not changed when an exception occurs, or the change that does happen, is
documented.
Since we need to react differently to different kinds of exceptional conditions, and exceptions are the best way to signal exceptional conditions, it is clear that we should make clear which kind of condition occurred as part of the exception.
Modern programming languages like Java and C# make this extremely easy: exceptions of different types can exist, and the mechanism for catching the exceptions is especially tweaked to allow different reactions to different types of exceptions.
Therefor, one of the main contributions of the
ppw-exceptions
library is the formal introduction of a
SemanticException
type and a TechnicalException
type. Yet, still we need more specialized exceptions, for particular
conditions. As described above, we need to communicate particular
information about the actual condition (to the end-user or the
administrator). The place where we are throwing the exception is where we
have the most complete information about the actual condition possible. The
further away we move from this place, the less complete the information we
have becomes. On the other hand, this is not the place to communicate with
the user. First of all, the code that is calling us might still need to deal
with the exception itself. It might even deal with the situation itself,
without notifying the end-user or the administrator. What is exceptional to
us, might be nominal to code above us. Furthermore, advocating a clean
separation-of-concerns, if we are now in a layer that is not the
presentation layer, we should not concern our self with end-user
communication. We should merely, semantically, gather the information
necessary, and report this information to the code that called us.
Now that it is clear what we want to do with exceptions finally, we can turn to the question when to throw exceptions. Again, we can consider the different kinds of exceptional conditions.
In general, we want to throw an exception when we cannot not or will not reach the nominal effect of the method we are implementing. As described, in correct code, this can be for semantic reasons or for technical reasons.
But when?
Recognize
we don't know that something is a programming error! so we can't throw them, only decide what to do them when we get one; difficult to recognize
Hey! That is the reasoning above about I don't care!
I must presume that we all want to deliver correct software. But we all know that is not trivial to. What is a good strategy to handle programming errors?
First of all, we should have a strategy that is aimed at discovering programming errors when the software is still in the hands of the programmers, before it is delivered. Secondly, we should have a strategy for dealing with programming errors that still remain in the software after it is deployed, despite our efforts.
usual things, prove, peer review, unit testing, integration testing, testing,
acceptance testing by selected audience
For dealing with programming errors that still surface when the software is deployed, we take into account the fact that this will be a rare occurrence. So we should not put too many effort in it. In this case it sadly is the end-user that is confronted with the error, so we need some explanation.
assert good enough; disable when you feel safe.
assert is good!!!!
Unchecked exceptions (and that includes errors) should be used to signal programming errors or technical exceptional conditions.
Problem is that that cannot be defined from the standpoint of the called method or operation: it can be called in different modes, and sometimes these are semantic or technical or error: the caller decides that, not the callee.


| This report gives a breakdown of the MIME and Scheme types used on your site. MIME types refer to different types of files such as HTML, images or executables. Scheme types refer to different URL protocols such as HTTP, FTP and mail. The last column in the tables shows the percent increase or decrease from the previous scan. |
| MIME SUMMARY |
File Type |
Internal |
External |
Total |
Percent |
% Change |
| HTML | 31 | 48 | 79 | 52 | 0 |
| Images | 51 | 1 | 52 | 34 | 0 |
| Executables | 1 | 0 | 1 | 1 | 0 |
| Audio | 0 | 0 | 0 | 0 | N/A |
| Video | 2 | 0 | 2 | 1 | 0 |
| Other | 4 | 14 | 18 | 12 | 0 |
| Total | 89 | 63 | 152 | 100 | 0 |
| SCHEME SUMMARY |


12 references to ThrowIfStopping
System.Management.Automation (12)
engine\MshCmdlet.cs (1)
914
_commandRuntime.
ThrowIfStopping
();
engine\MshCommandRuntime.cs (11)
170
ThrowIfStopping
();
248
ThrowIfStopping
();
337
ThrowIfStopping
();
1488
ThrowIfStopping
();
1935
ThrowIfStopping
();
2061
ThrowIfStopping
();
2622
ThrowIfStopping
();
2653
ThrowIfStopping
();
2719
ThrowIfStopping
();
2832
ThrowIfStopping
();
3428
ThrowIfStopping
();


@(message: String) @main(message) {
Living with someone else is a big deal! You wouldn't go on a date with someone you didn't know anything about, would you? Why sign a year-long lease with them? At Symbi, you can trust our verified network of vetted users.
We know every living situation is unique, and we'll match according to what's important to you. From our first meeting to help with signing your lease, we want to give you the personalized attention you deserve.
At Symbi, data-driven is our culture. Everything we do, from features to our matchmaking model, is grounded in thorough research. So you can benefit from the experiences of others - without having to go through it yourself.
No more poring through hundreds of listings - Symbi saves you time, money, and headache by getting you to the right person. Fast.
Narrowing down the right person is a tough job! We find you great roommate candidates so you can focus on picking just the right one.
This means you can expect more personalized attention - including in-person meetings, video calls, and personal e-mails - as we perfect our service. Sign up today. We look forward to working with you!


Max grew up in beautiful New Jersey, and had a generally unremarkable childhood. After attending college in Maine and majoring in Psychology, Max was a middle school math teacher in Brooklyn for two years. Hoping to work on similar issues of inequity in cities, Max began a career in urban planning in the Bay Area. Max worked for the City of Berkeley and an affordable housing think tank in San Francisco. Max is currently working towards a Master of City Planning degree at MIT. In his free time, Max enjoys cooking spicy food, hiking, and listening to music.
A visualization that Max finds particularly inspiring is the Wind Map, created by Hint.FM using data from the National Oceanic and Atmospheric Administration.


About Me
My name is Terence Lau. I was born in 1998 and I am now a statistics Undergradute studying BNU-HKBU UIC .
I am one of the members of @UICHCC (UIC
Computer Club) and Cyclododecene, a data
analysis group; for more imformation: ABOUT ; Also, I am a
Markdown Programmer
Research Interest
- Statistical methods in linear model and generalized linear model
- Bayesian Statistics
- Statistics Computing
- Deep Learning and Machine Learning
Skills
- C
- Python
- R
- MATLAB
- Git
- SQL
Activities
-
Google DevFest 2017 联动嘉年华
- 中国·广州荔湾科创广场
(Nov, 2017)
-
UIC Statistics Alumni Conference
- UIC Campus,Zhuhai,China
(Dec, 2017)
-
Volunteer Service (Marine Conservation)
- Qi,ao Island,Zhuhai,China
(Dec, 2017)
-
Student Volunteer(New Campus Celebration)
- UIC Campus,Zhuhai,China
(Dec, 2017)
-
Peer Mentor (Mentor Caring Programme)
- UIC Campus,Zhuhai,China
(May, 2018)
Experiences
-
网络建设与数据维护
- 中国，广东·深圳-隆顺盛电子化工发展有限公司
(August, 2017)
Tools: HTML   CSS   Shell
-
服务器搭建与维护
- 中国，广东·珠海 BNU-HKBU UIC
(Since: September, 2018)
Tools: Shell   python   KVM   Openstack   VNC
-
个人开源项目：Using-X-Series (Using - Python, R, MATLAB in Statistics)
- 中国，广东·珠海 BNU-HKBU UIC
(Since: October, 2016)
Tools: Python   MATLAB   R   Git
Contact


Use Eq. (49) and the deﬁnition g ≡ RBϕ, the poloidal components of the current density, JZ and JR, can be written as
|
| (50) |
and
|
| (51) |
respectively.


Desert
Click on the picture below.More directions on the next page.
PLEASE SCROLL DOWN!!!!!!
There is not very much in this picture,but its probably enough for you.


BEIJING: Chinese scientists have successfully developed a new cheaper way of getting connected to internet by using signals sent through light bulbs instead of radio frequencies as in Wi-Fi, a move expected to radically change process of online connectivity. Four computers can be connected to internet through one- watt LED bulb using light as a carrier instead of traditional radio frequencies, as in Wi-Fi, said Chi Nan, an information technology professor with Shanghai's Fudan University. !
Try To Understand each other .!!  2) If A Person Sleeps A Lot, He Is Sad. 3) If A Person Speaks Less, But Speaks Fast, He Keeps Secrets. 4) If Some One Can't Cry, He Is Weak. 5) If Some One Eats In An Abnormal Manner, He Is Tensed. !
The stellar evolution starts with the formation of the star from the interstellar matter like gas and dust in the galactic environment. The interstellar gas and dust containing most of the hydrogen experiences a gravitational collapse and contracts to a Prostar. The mass of the prostar depends on the mass it can aggregate through the gravitational collapse. Further dynamical gravitational collapse of the prostar generates sufficient temperature to ignite hydrogen fuel (Nuclear fusion). While burning, the radiation emitted keeps the star expanding until it is equal to the pressure due to gravitational collapse. A burning star looses mass since it sheds energy..


Write your First Program
Now that you’ve taken the Quick Tour, let's dig a little deeper and write your first Ballerina program. This tutorial will teach you how to run Ballerina in standalone and server mode, use the editor to build your program, understand the key concepts, and get familiar with the Ballerina language.
Run Ballerina
In the Quick Tour, you learned how to start Ballerina and run a sample program from the <ballerina_home>/samples/helloWorld
directory with a single command:
ballerina run main helloWorld.bal
After the HelloWorld program executed, Ballerina stopped. This approach is called standalone mode, and it's useful when you want to execute a program once and then stop as soon as it has finished its job. It runs the main()
function of the program you specify and then exits.
You can also run Ballerina as a server, so that it can deploy one or more services that wait for requests. To see how this works, let's go to your <ballerina_home>/samples/helloWorldService
directory, and then run Ballerina in server mode and deploy the HelloWorldService program:
ballerina run service helloWorldService.bal
In this case, Ballerina ran and deployed the HelloWorldService program as a service, which is waiting for a request. Let's send it one now. The Ballerina server is available at localhost:9090
, and HelloWorldService is available at context hello
. Open another command line window and use the curl client to call the service as follows:
curl -v http://localhost:9090/hello
The service receives the request and executes its logic, printing "Hello, World!" on the command line. Notice that the Ballerina server is still running in the background, waiting for more requests to come in. You can stop the Ballerina server by pressing Ctrl-C.
Create a new program
It's time to create your first program! In this exercise, we are going to create a service that takes an incoming message, extracts the text, and sends a message back to the client with that same text.
Add a service and resource
First, we add a service construct to the canvas in the Composer. A service is a container for all the other constructs and represents a single unit of functionality that can be accessed remotely.
- If the Composer is not already running, run it as described in the Quick Tour.
- On the Welcome page, click New.
- On the tool palette, click the service icon and drag it to the canvas.
A box appears called Resource1
with some content already created for you. If you scroll up, you can see that it is inside another box called Service1
, which is the top-level container for the service.
A resource is a single request handler within a service. This is where we will program the logic describing how to handle certain types of requests from incoming messages to this service. The diagram shows that when clients send messages to this service, they are received by the Resource1
resource, which has one worker that handles the message. Each worker is a separate thread of execution, so you can add more workers if you want to do parallel processing. In this tutorial, we'll just use the default worker.
By default, the resource is configured to accept a message m
. You can see this by clicking the Arguments icon in the upper right corner of the resource box:
When you click it, you'll see message m
listed below the fields. Click the Arguments icon again to close its window.
Let's rename the service and resource.
- Highlight the name
Service1
and typemyEchoService
in its place. - Change
Resource1
tomyEchoResource
in the same way.
Set the base path
The base path for a service is the context portion of the URL that clients will use to send requests to this service. For example, if we set the base path to /myecho
, clients will be able to send requests to this service using the URL http://localhost:9090/myecho. Let's do this now.
- In the upper right corner of the myEchoService box (not the resource box this time), click the Annotations (@) icon.
- Make sure
http:BasePath
is selected in the list, type/myecho
in the text box, and then press Enter or click the + symbol to its right.
The base path is now set, so that when you deploy this service, clients will be able to send requests to it using http://localhost:9090/myecho.
Change GET to POST
When you added the service, Ballerina configured the resource to use the GET method by default. Because we are going to use the incoming message to post a reply, let's change it to POST.
- Click the Annotations (@) icon in the upper right corner of the myEchoResource box (not the service box).
- Click
http:GET
, highlightGET
, and typePOST
. - Click the Annotations icon again to hide the box.
You can click the symbol again to confirm that GET was in fact changed to POST. You can also click the Source View button in the lower right corner to see the changes that are being made to the Ballerina code as you work with the visual editor. Currently, the source code should look like this:
@http:BasePath{value:"/myecho"}
service myEchoService {
@http:POST {}
resource myEchoResource( message m) {
}
}
Add a function
Now, let's add a function that will take the incoming message and convert it to a response that gets sent back to the client. Because we are sending the original request back instead of composing a new message to send to the client, we need to strip its original headers before we reply, as those headers are intended for use in the client -> server direction and not the other way around. The ballerina.net.http
package includes a native function called convertToResponse
that removes the incoming HTTP headers when replying to the client. Let's add that function to our flow.
- Click Design View.
- On the tool palette, scroll down and click the ballerina.net.http section to expand it, click the convertToResponse function, and drag it to the canvas below start.
- Highlight
message
inhttp:convertToResponse(message)
and replace it withm
, which is the incoming message, so that it looks like this:http:convertToResponse(m)
Add the reply
Now that we've added the function that will convert the incoming message text to a response, we just need to instruct the program to send the response back to the client. We will use the Reply icon in the tool palette, which looks like this:
-
On the tool palette, click the Reply icon and drag it to the canvas under the
convertToResponse
function you just added.It appears as a box with an arrow pointing back to the client.
-
Click the reply box you just added and type
m
to instruct the program to send the message processed by theconvertToResponse
function back to the client. Click outside of the box.
This completes the sequence. If you go to the Source view, your program should now look like this:
import ballerina.net.http;
@http:BasePath{value:"/myecho"}
service myEchoService {
@http:POST {}
resource myEchoResource( message m) {
http:convertToResponse( m );
reply m;
}
}
Notice that the ballerina.net.http
package has been imported, and the convertToResponse
function and reply
statement appear within the resource definition.
You are now ready to save and run your integration program
Save the program
- Click the File menu and choose Save As.
- Specify the name as
myEcho.bal
and specify the location as your Ballerinasamples
directory. You can type the path directly in the Location box, or use the tree to navigate to the directory. - Click Save.
Run the program
You can run a Ballerina program from inside the Composer using the Run icon, which is to the left of the tool palette:
Click the Run icon now and click Service. If you were creating a Ballerina program with a main()
function, you would click Application instead.
Your service is now deployed and running on the Ballerina server.
Send the request
In a new command prompt, use curl to send the following request to your program:
curl -v http://localhost:9090/myecho -d "Hello World......"
The service receives the request, takes the text Hello World......
from the incoming message, converts it into a response without the client headers, and sends it back to the command line where the request was sent.
You have now completed your first Ballerina program!
Next steps
Now that you're familiar with running Ballerina in standalone and server mode, using the Composer to build a program, and creating a service and resource, you are ready to learn more.
- Read the Key Concepts page to familiarize yourself with the rest of the primary features you need to know about.
- Read about the Tools that you can use with Ballerina, such as using an IDE instead of the Composer.
- Run through the rest of the Tutorials to get hands-on experience.
- Browse through the Samples and use them as templates for your own programs.
- See the Language Reference for complete information on using the Ballerina language.


If you want to monitor security access, you can set the java.security.debug
System property. To see a list of all debugging options, use the help
setting:
java -Djava.security.debug=help
Note:
Separate multiple options with a comma.
For more information, on debugging utilities please visit JSSE Reference Guide.
The following table lists java.security.debug
options and links to further information about each option:
| Option | Description | Further Information |
|---|---|---|
all |
Turn on all debugging | |
access |
Print all results from the You can use the following options with the
You can use the following options with the
|
|
certpath |
Turns on debugging for the PKIX CertPathValidator and CertPathBuilder
implementations. You can use the ocsp option with the certpath option for OCSP protocol tracing.
A hexadecimal dump of the OCSP request and response bytes is displayed. |
|
combiner |
SubjectDomainCombiner
debugging |
|
gssloginconfig |
Java GSS (Generic Security Services) login configuration file debugging |
|
configfile |
JAAS (Java Authentication and Authorization Service) configuration file loading | |
configparser |
JAAS configuration file parsing | |
jar |
JAR file verification |
|
logincontext |
LoginContext
results |
|
policy |
Loading and granting permissions with policy file |
|
provider |
Security provider debugging |
|
scl |
Permissions SecureClassLoader assigns |


;;off words break
(global-visual-line-mode t)
use pandoc convert html to org-mode file
% pandoc -o cheatsheet.org -f html -t org 'http://sce2.umkc.edu/BIT/burrise/pl/modeling/qanda.html' Fetching http://sce2.umkc.edu/BIT/burrise/pl/modeling/qanda.html... pandoc: Cannot decode byte '\x92': Data.Text.Internal.Encoding.Fusion.streamUtf8: Invalid UTF-8 stream %
UPDATE: It looks like the problem was with web-page it self! I tried it with another HTML website and it works juts fine (need some formatting but almost all the job has been done, thanks to pandoc):
% curl http://anh.cs.luc.edu/170/notes/CSharpHtml/sorting.html > foo.html % pandoc -o foo.org -f html -t org foo.html
modify the fcitx didn't work under openbox OS.
cd /usr/share/applications ;;pay attention to the folder is application, not applications. ls fc* cp fcitx.desktop ~/.config/autostart/
Modify the problem of the wifi 固件缺失
sai firmware-linux-free
git clone git://git.kernel.org/pub/scm/linux/kernel/git/firmware/linux-firmware.git
git clone git://git.kernel.org/pub/scm/linux/kernel/git/romieu/linux-firmware.git
sudo cp -r linux-firmware/rtl_nic/ lib/firmware
sudo update-initramfs -u
lspci
lspci -nn | grep Network
s discover –vendor-id –model-id pci | uniq
sai firmware-brcm80211
How to execute command on startup (rc.local alternative)
which involves use of systemd here:
- Create a service:
sudo vi /etc/systemd/system/rc-local.service
- Add your code there:
[Unit] Description=/etc/rc.local Compatibility ConditionPathExists=/etc/rc.local [Service] Type=forking ExecStart=/etc/rc.local start TimeoutSec=0 StandardOutput=tty RemainAfterExit=yes SysVStartPriority=99 [Install] WantedBy=multi-user.target
- Create and make sure /etc/rc.local is executable and add this code inside it:
sudo chmod +x /etc/rc.local
#!/bin/sh -e # # rc.local # # This script is executed at the end of each multiuser runlevel. # Make sure that the script will "exit 0" on success or any other # value on error. # # In order to enable or disable this script just change the execution # bits. # # By default this script does nothing. exit 0
- Enable the service:
sudo systemctl enable rc-local
- Start service and check status:
sudo systemctl start rc-local.service sudo systemctl status rc-local.service
If all goes well you can add your code to the /etc/rc.local file then restart it.
openbox close sleep and screensaver
#xset s 300 #设置屏保时间为300秒，时间单位为秒 #xset s 0 #关闭屏幕保护 #xset dpms 0 0 0 # 三个数值分别为Standby、Suspend、Off，单位秒 #xset -dpms #关闭电源管理
openbox environment setup
Setting up your environment
If you would like to set environment variables that will affect everything run in your current session (including Openbox), you can place them in ~/.config/openbox/environment. Here's an example ~/.config/openbox/environment file:
# Set up my own path export PATH=$HOME/bin:$PATH # Change the language used from the system's default export LC_CTYPE=ja_JP.utf8 # SCIM for typing non-english characters export XMODIFIERS=@im=SCIM export GTK_IM_MODULE=scim export QT_IM_MODULE=scim
openbox keyblinding setup, ~/.config/openbox/rc.xml
<!-- Keybindings for running applications --> <keybind key="W-e"> <action name="Execute"> <startupnotify> <enabled>true</enabled> <name>kfmclient</name> </startupnotify> <command>pcmanfm</command> </action> </keybind>
chane the _app/assets/themes/curtana/_less/common.less
table { tr:nth-child(even){background-color: #f5f2ff} th { background-color: #cC0Ff0; color: white; } // TODO: responsive table support - // display: inline-block; - // overflow-x: auto; - // white-space: nowrap; + display: inline-block; + overflow-x: auto; + white-space: nowrap; }
and then the TABLE had 横拉滚动条
A friend sent me an email with a JPEG photo in the middle of the text. The picture is so big, most of it is outside the screen and I want to view it with an outside image viewer and not in Gnus. How do I save an image that is included in the email in Gnus, if it's not just an ordinary attachment?
The command you need is gnus-summary-save-parts. You have an inline image, which implies that you received an HTML mail. An inline image is an instance of a so-called MIME part, where MIME is an Internet standard governing email-related things such as non-text attachments.
L ;;list all group of gnus X m ;;save image to ~/
debian chrome extensions installation is not enabled.
se /etc/environment
CHROMIUM_FLAGS='–enable-remote-extensions'
export WINEARCH=win32
export WINEPREFIX=$HOME/.mynewwine32prefix/
bash winetricks dotnet30
proxychains4 bash winetricks dotnet40
wget kegel.com/wine/winetricks && sh winetricks ie8 ;;this is too old.
emacs: error while loading shared libraries: libpng12.so.0: cannot open shared object file: No such file or directory
https://packages.debian.org/jessie/libpng12-0
s dpkg -i lib*
s apt-get install -f
install wine-qq on debian
http://www.longene.org/forum/viewtopic.php?f=6&t=30516
change emacs' color in terminator, add this line to .bashrc
export TERM=xterm-256color
define terminator's default position, change the '.local/share/applications/terminator.desktop' to:
terminator –geometry=1200x900+0+0
add the font of msyh.ttf
define the font by #gnome-tweak-tool
#spni -g n ;; to install npm's extension n
#s n 7.2.1 ;;to install nodejs v7.2.1
.emacs
L625
(setq myvar/relative-filename (concat "http://yefeiyu.github.io/assets/img/" myvar/img-name))
sudo apt-get install bleachbit
sudo apt-get install sweeper
sudo apt-get remove sweeper
sudo dpkg -i nautilus_nutstore_amd64.deb
install vmware debian and windows xp.
debian:
sai xfce4
add 6 keyboads shortcut, such as emacs, conkeror, gnus
change the desktop to 600x800, which need change the VGA1 to Virtual1
rehook dropbox to home/xx/Dropbox
change conkerorrc's qiushi to 98%, and /.
eba
alias gl='git pull'


@*******************************************************************************
* Licensed to the Apache Software Foundation (ASF) under one or more *
* contributor license agreements. See the NOTICE file distributed with *
* this work for additional information regarding copyright ownership. *
* The ASF licenses this file to You under the Apache License, Version 2.0 *
* (the "License"); you may not use this file except in compliance with *
* the License. You may obtain a copy of the License at *
* *
* http://www.apache.org/licenses/LICENSE-2.0 *
* *
* Unless required by applicable law or agreed to in writing, software *
* distributed under the License is distributed on an "AS IS" BASIS, *
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
* See the License for the specific language governing permissions and *
* limitations under the License. *
*******************************************************************************@
@(workflowForm: play.data.Form[metadata.Workflow])
@import helper._
@scripts = {
}
@main("Add Workflow", scripts) {
@flash_message()
@if(true){


Reports unbalanced wiki syntax headers and the ignored text after such headers in Scaladocs.
In the following example, ====
is marked:
/**
* == I'm a wiki style header ====
*/
def test(i: Int): Unit = {
}
In the following example, Ignored text
is marked:
/**
* == I'm a wiki style header == Ignored text
*/
def test(i: Int): Unit = {
}


Creat your VHSBD Account as a Doctor
Already have an account ? Login
Name
Email
Contact no.
Date of Birth
Gender
Specialization
Prefarable Time (From)
Prefarable Time (To)
Prefarable Day
Address
Qualification
Educational Institution
BMDC Reg.
UserName
Password
By clicking "SIGN IN" I agree to VHSBD Privacy Policy


UDISE Report for: {{state}}
UDISE Report for: {{state}} / {{districtHierarchy.districtName}}
UDISE Report for: {{state}}/ {{blockHierarchy.districtName}}/ {{blockHierarchy.blockName}}
UDISE Report for: {{state}}/ {{clusterHierarchy.districtName}}/ {{clusterHierarchy.blockName}}/ {{clusterHierarchy.clusterName}}
About the dashboard: The dashboard visualises data on various indices calculated using the metrics captured in the UDISE 2019 for {{state}}. Each of the indices has been derived using multiple metrics that have been normalised and benchmarked for a fair comparison. The data here can be broken at multiple administrative levels (i.e. District, Block, Cluster and School) and you can view and download the data for any of the available indices.


This is a simple demo on how to use the DccLib library with a JavaScript project.
Please upload or scan a valid covid certificate QrCode.
Set your trust anchor by providing a root certificate.
This demo uses the Swiss Government's root certificate "CA II" per default.
You can also provide a custom list of DCC keys as a Json Web Token (JWT).
Make sure that the JWT header and payload follow the same structure as provides by the Swiss update list.
more info.


@require("../partials/head.html")
PrankWeb builds upon P2Rank a machine learning-based method for prediction of ligand binding sites from protein structure.


Applications
Dialog Processing
Speech Recognition
Text Mining
Information Extraction
Information Retrieval
Question Answering
Text Summarization
Machine Translation
"Small" Applications
Wordsense disambiguation
Coreference
Sentiment
Entailment
Basic Operations
Informatin Transformation Techniques
Evaluation Techniques & measures
Tools
Annotation Techniques & measures
Resources
Theories


All Lehigh CustomFit products have a 1-year, limited warranty in normal use against any manufacturing flaw(s), defective materials and workmanship. This warranty also covers Gore-Tex® bootie liners against leakage for 1 year. All boots with Rocky waterproof constructions are guaranteed waterproof for 6 months from date of purchase.
The Lehigh CustomFit warranty does not cover damage due to holes worn in toes, burn marks, punctures, cuts, and abrasions from outside causes or misuse and/or abuse by the wearer. The warranty may be void if the user applies any materials not recommended, such as polishes, oils, or other chemicals that result in damage to the materials of the footwear.
All products must be returned and inspected before full credit is issued or a replacement of the same or equal value is given. Lehigh CustomFit does not pro rate or offer partial credit. We will replace all products at our discretion.
If footwear was purchased directly from Lehigh CustomFit please contact 1-800-444-4086 to obtain your return authorization number. If your boots were not purchased from the Lehigh CustomFit website, this warranty is voided.
We think you'll love our products. If you don't, just return them in 60 days for a full refund.
Free shipping and free returns always, forever, for anything. And we really do mean it.
Protective toe products are warranted against manufacturer defects for 365 days from purchase date.
• Must have receipt or website order number
• Closeout/clearance items not included
• Returns not accepted if product is subjected to excessive/unusual wear
• Expedited shipping options available
• Denials will be notified via email


| Author | Changes | Lines of Code | Lines per Change |
|---|---|---|---|
| luebbe.tortoisesvn | 2 (100.0%) | 26 (100.0%) | 13.0 |
Pulled latest translation changes from transifex.com
Partial update to German doc translation
Finish German UI translation
26 lines of code changed in 2 files:


Hi! I'm Andie. I am a junior at Northwestern University studying Computer Science and Gender & Sexuality Studies. Thank you for visiting my website!
My areas of interest are in front-end design and video game development. I hope to use my gender studies background and personal experiences of disability to create diverse and accessible games!
I'm from Wichita, KS, Jefferson City/Columbia, MO, and am currently residing in Chicago, IL.
In my free time, I love to dance and play Minecraft, Persona5, and the Sims.
I have two cats, Kitty (9) and Rosie (1). They are the most precious beings, as evidenced by the Cat Emergency button on my homepage!
Proudly Latina, LGBTQ+, and disabled.


Top 10 Favorite Books!
- The Remains Of The Day by Kazuo Ishiguro
- The Pillars Of The Earth by Ken Follet
- Business Adventures by John Brooks
- Lean In by Sheryl Sandberg
- Liar's Poker by Michael Lewis
- Disciplined Entrepreneurship by Bill Aulet
- The Rational Optimist by Matt Ridley
- Evicted: Poverty And Profit in an American City by Matthew Desmond
- The Alchemist by Paulo Coelho
- The Undoing Project by Michael Lewis
10 Things About Me.
- I'm an introvert.
- I have 4 daughters.
- I like to read multiple books at once, but will only finish books that are interesting.
- I drive a car that cost $100 -3 years ago.
- I love coffee.
- My favorite life advice is a letter someone shared with me. Letter To Hume on Finding Your Life's Purpose.
- My most popular Instagram face filter just hit 100 Million impressions today. Try it here!
- I'm highly ambitious.
- I collect vintage Jadeite glass.
- I love music.


Install Options¶
Install vidstab
without installing OpenCV¶
If you’ve already built OpenCV with python bindings on your machine it
is recommended to install vidstab
without installing the pypi
versions of OpenCV. The opencv-python
python module can cause issues
if you’ve already built OpenCV from source in your environment.
The below commands will install vidstab
without OpenCV included.
From PyPi¶
pip install vidstab
From Github¶
pip install git+https://github.com/AdamSpannbauer/python_video_stab.git
Install vidstab
& OpenCV¶
If you don’t have OpenCV installed already there are a couple options.
- You can build OpenCV using one of the great online tutorials from PyImageSearch, LearnOpenCV, or OpenCV themselves. When building from source you have more options (e.g. platform optimization), but more responsibility. Once installed you can use the pip install command shown above.
- You can install a pre-built distribution of OpenCV from pypi as a
dependency for
vidstab
(see commands below)
The below commands will install vidstab
with
opencv-contrib-python
as dependencies.
From PyPi¶
pip install vidstab[cv2]
From Github¶
pip install -e git+https://github.com/AdamSpannbauer/python_video_stab.git#egg=vidstab[cv2]


To represent Consolidated CDA Templates for Clinical Notes (C-CDA) 2.1 templates using FHIR profiles.
This first stage of the project defines all the C-CDA document-level profiles on the Composition resource and contained sections.
Any coded data used by sections will be represented using relevant U.S. Core FHIR profiles where they exist. FHIR profiles defined by other work groups or unconstrained FHIR resources may also be referenced if no appropriate US Core Profile exist.
Implementers moving from C-CDA to FHIR need to be aware that the goal of this project is to address the same use case as Consolidated CDA (clinical documentation for primary and transfer of care scenarios in the US), but the syntax, methodologies, and value sets in FHIR are often quite different from those in C-CDA. In particular, implementers need to be aware of the issues listed below:
Implementers need to follow the rules and apply the value sets used by the target specification, and this will often require significant data and vocabulary mapping. implementers moving from C-CDA to C-CDA on FHIR will need to review the US Core profiles and value sets in core FHIR resources and ensure that their instances FHIR instances are compliant. We hope that ongoing work in HL7 will better align US Core, C-CDA, and the Core FHIR specifications in the future.
We encourage implementers to refer to the ongoing C-CDA to FHIR mapping work that is described on the C-CDA on FHIR wiki page for assistance when moving from C-CDA to FHIR.
| Name | Definition |
| HL7 Implementation Guide for CDA Release 2: Consolidated CDA Templates for Clinical Notes | The Consolidated CDA (C-CDA) implementation guide contains a library of CDA templates, incorporating and harmonizing previous efforts from Health Level Seven (HL7), Integrating the Healthcare Enterprise (IHE), and Health Information Technology Standards Panel (HITSP). It represents harmonization of the HL7 Health Story guides, HITSP C32, related components of IHE Patient Care Coordination (IHE PCC), and Continuity of Care (CCD). C-CDA Release 1 included all required CDA templates in Final Rules for Stage 1 Meaningful Use and 45 CFR Part 170 Health Information Technology: Initial Set of Standards, Implementation Specifications, and Certification Criteria for Electronic Health Record Technology; Final Rule. |
| U.S. Core FHIR Implementation Guide | A U.S. Realm guide for making use of FHIR resources to support queries between systems within an enterprise and across enterprises |


KBOT is a brand consultancy that delivers
dynamic, engaging marketing strategies
and design solutions to brands, ad agencies,
and businesses.
Our creative, solution-driven team specializes
in building brands that are unique in
personality, look, and action.


Multisearch French Words
This site searches words in French to help an English speaker build flash cards by searching:
- French Wiktionary: For word definitions and use
- Linguee: For word sounds and definitions
- Forvo: To hear pronunciations of words
- Google Images: Get images to choose to build the flash card


Care Packages are random equipment drops from passing airplanes which contain ammunition, weapons, equipment, and other things. The planes can be heard well before they drop the equipment. A red smoke will appear on the spot where the care package lands. They can drop up to two care packages.
Care Package Items:


Last month, we finished an awesome vodQA event in our Thoughtworks Pune office. During the event it was encouraging to see a lot of interest in Performance Testing. But slightly disappointing to see all of those discussions tending towards “Load Testing”.
“Load Testing” typically gives us insight into server-side performance. But there is a lot more to performance testing than just measuring server-side performance. Back in 2010 Steve Souders wrote about frontend SPOF. He makes an important observation:
”.. we’ve learned that 80% of the time users wait for a web page to load is the responsibility of the frontend.”
Fast Forward to 2014 and the world has been moving towards even more distributed applications. Networks are being re-written and there is already a huge momentum behind Internet of Things (IOT). Our Application’s performance matters and it will do more so in the coming years. But If “Load Tests” are the only performance tests for our application, then we have a slim chance of identifying performance issues upfront. Server-side performance is important but equally so is the performance of our client-side code, network, infrastructure and even the 3rd party libraries that you use. On this journey to understand application performance, I would like to start with some very basic questions:
1. What really is well performing code?
The answer to this question lead me to the basics of computer science. And I came across some excellent examples in Princeton University’s Analysis of Algorithms. How do we quantify code performance? Well, the easiest measure for a program’s performance is its “running time”. And as mentioned in this book:
The total running time for a program is determined by two primary factors:
- The cost of executing each statement. (A property of the system)
- The frequency of execution of each statement. (A property of the algorithm)
This means that performance of code depends as much on the underlying system as its algorithmic efficiency. And really, the underlying system is not merely a single computer. These days, it is made up of complex mix of multi-layered software code sitting on top of a variety of hardware systems which are interconnected via different network mediums. And that leads me to the question that has been bugging me for a while..
2. Whose performance are we are trying to test?
I feel this is an important question to soak-in before we begin with any performance testing exercise. With the complex and multi-layered systems that we work with today, there are different things that could hurt an applications performance. Have a look at a sample web application architecture pictured below. And then its time for some examples
Examples:
-
Server-side code is sub-optimal but functionally working fine.
Going by the above picture, our server-side code has a lot of computing power at its disposal. And hence it should not have survival issues. Typically, a good load testing exercise should point this out. But unless there are major defects, we might just decide to live on with some additional computing power.
Client-side code runs on each one of the individual clients (typically with limited computing resources). Hence, this is where we should be be shifting the focus of our performance tests. Tools like YSlow and PageSpeed should be able to get us started. -
All our code is super awesome. But our servers are in a different country than our target audience.
I feel the real question here is: How early can can we detect such issues? A simple web page test should point this out. But ideally we should create continuous probes from across the target locations to keep our web-application well performing. -
Again, all our code is super awesome. But our audience only uses wireless networks to access the web-application.
Is my website optimised for wireless access? With the mobile revolution around us, this is is another important aspect of our web-application performance. Tools like Mobitest are relatively new on the block. But surely worth a try.
To Summarize: it is really important that we look at all aspects of application performance before we try to measure it. And again a good way to get started is to ask some simple questions:
- Are we trying to test the performance of the piece of code that we just wrote?
- Do we want to test the code performance when it is deployed in an application or web server?
- How do I get alerted when there is change in overall application performance due to the small code change that I made?
- Are we trying to tweak our web or application server settings for faster response times?
- Do we want to come up with some performance figures for Capacity planning?
- How much peak load would the application handle? How does it scale?
- Are we trying to monitor the performance of our live application?
- Are we checking for bottlenecks in the Application Infrastructure?
- Do we want to check for performance problems from an End User Perspective?
- Validate that the application’s response times are within the required threshold
- Validate that the application’s response times are similar across our target (audience) locations
- Validate that the application’s response times are similar when accessed from different network types
These are all important questions that try to address different aspects of application performance. They should help us design specific testing experiments and in-turn help uncovering performance problems. Essentially, I would classify these into 3 different categories:
- Lower Level tests that are closer to code (Questions 1-3)
- Higher Level tests that are more from the system perspective (Questions 4-6)
- Real User Measurements (Questions 7-9)
In my next post, I plan to dig deeper into each of these aspects and come up with strategies and tooling. But, if you’ve got this far I would love to hear from you. Did I miss something? Do you have better suggestions? Please do leave your comments…..


ListJuggler Examples
You should have been automatically redicrected to the examples.
Go to the examples
Source Code


Things I've worked with, this could be a very long list but I prefrer to keep it simple wit major stuff!


I have wanted to try psychedelic substances for a while. Once my friend's boyfriend (who is a dealer) got a hold of mushrooms, he sold me a 1/8 ounce for $35 which seemed to be a reasonable price.
It was about 12 PM on a Sunday and I invited a few people over to watch me as I went on my 'journey.' No one else was willing to try the drugs with me so I was the only one tripping. I first ate half of the 1/8 ounce bag of shrooms (which really didn't taste that bad so I don't know why people say they do) After an hour of nothing happening (probably because I had eaten breakfast prior to eating the shrooms), we went for a ride to drop somebody off at their house and by then I was feeling really queasy. I already get car sick a lot but the shrooms in my stomach made it worse. Then my knees started feeling all tingly and I started laughing a lot, but still I wasn't seeing things.
I got back to my house where I ate the rest of the bag and watched more videos. Still... nothing happening, and it's been at least 2 hours by now.
At approximately 3 PM, the three of us decided to go for a walk to the park behind an elementary school. Then it started raining and storming which was PERFECT and exactly how I wanted my trip to go. At first I felt as light as a feather and was floating through the air. Patterns started forming in the grass and the trees. My jaw kept tightening and could barely talk, so I was generally silent throughout my trip. It felt weird later on during the trip when I wanted to eat and drink something. I was taking little bites of my food because of all the muscle tension I had in my jaw. I remember also shaking quite a lot, but maybe that was just out of nervousness, I don't know.
The sound of the rain, the thunder rolling in the sky, the green trees and grass... EVERYTHING came alive and I felt like I was in a jungle. I was so excited. *D* noticed that my eyes were dilating so much that they almost turned completely black. By then I knew there was no turning back to reality for a while.
Everything started turning colors and was more intensified, but little did I know this was just the beginning of my trip. All of the plants and trees morphed into kaleidoscopic patterns that I felt I was staring at for hours and hours. I remember looking at these clutter of clovers on the grass and they morphed into patterns that soon took over the concrete. By then the patterns which looked exactly like kaleidoscopes started rising from the ground and I felt like I was getting shorter and sinking into the ground. I looked over at my friend and at this point she had four eyes and a discolored face. I wasn't scared of it.... a little nervous, but not scared because everything was too beautiful to be scared of it. I kept telling myself that it was only the drug that was doing it to me, even though everything looked as if it WAS real.
I was running through the grass and under the trees and into the rain just laughing and enjoying my peak. I felt like I was a child of nature. I think shrooms really helped bring out my inner-child that I knew was in me somewhere. It was great and just what I had wanted.
We stayed at the park for what seemed like the longest time because I kept getting lost in the kaleidoscopic patterns and the sounds all around me. The rain and the birds chirping never stopped. Everything kept repeating itself. If I heard the sound of a bird flying by, it would be chirping forever, but it was pretty and sounded like a song that never ended.
 The cars going by did annoy me because the sound never stopped and they seemed to be going by very slowly, too. I remember seeing the cars bending as they came around the corner. I was paying attention to all of the sounds and visuals around me which after a while got really annoying because that's all there really was. I couldn't concentrate on anything else. When people tried to have a conversation with me and ask me questions, I couldn't pay attention to what they were saying and wanted them to shut up because they seemed to be ruining my experience.
Everything was morphing into shapes and glowing. The sky was pure white, the whitest sky I've ever seen. I barely made a sound the whole time I was walking because I was only paying attention to the thoughts in my head.
We finally made it to my house and decided to chill out in my room for the remainder of my trip. Everything was spacey and if I walked a step then it felt like a giant leap. I had no sense of time or space whatsoever. I kept jumping around to places and couldn't sit still. I found like I kept repeating all of my actions and thoughts and words because at this point, all these thoughts kept coming into my mind which actually isn't unusual when I'm sober, but when I'm tripping it's obviously more intense. I was jumping from one thought to another.
It seemed like everything in the universe started making sense, but at the same time it didn't which was weird. I started questioning my life more and even my death. When I thought about death, the more I didn't want to die because life was so beautiful and I never wanted it to end. I wanted to live FOREVER. It's like when people say they see a 'white light' before they die... it was similar to that.
At this point there was a force inside me that wanted to 'break free' and made me realize that I need to stop destroying my life and start to appreciate everything and everyone around me. I wanted to hug everyone around me, even if I already hated them.
For the rest of my trip I kept seeing patterns everywhere and listened to some hippie music. I could now start to hold conversations with people because my thoughts seemed to calm down after I was coming down from my trip, and my jaw was loosening up a bit. My trip lasted for 3-4 hours, but in my mind seemed like an eternity.
After it was all done I was never happier to finally be back to reality and was really excited to tell everyone what I saw and experienced that I really wish I had someone to share it with.
Conclusively, shrooms gave me a mind opening vision of the universe and my place in it. For some people tripping is about the 'cool' visuals and 'tripping balls,' but for me it was more than that. It was more spiritual. I felt like I was given a special gift that I could never give back. I learned to appreciate everything around me a lot more and faced some of my fears. Even days after the trip, I feel like a generally happier and more mellow person. Prior to my experience I was chronically depressed.
The only negative things that I have to say about the whole experience was the jaw clenching, the points of good and bad hearing, mental confusion, and the slight nausea.
Is it something that I'd do again? Quite possibly, but not anytime soon. But the next time I try it I would definitely not like to be the only one tripping.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Tamzid Ahmed
Portfolio
Tired warrior
I have learned to fall and stand again and again
Yet I did not learn to lose


YOUR FRIENDS AND NEIGHBORS A film review by Matt Williams
RATING: * * * out of * * * *
Those familiar with Neil LaBute's directoral debut, In the Company of Men, know that he knows how to tap the baser instincts of mankind. His second film, Your Friends and Neighbors, continues in the same spirit, showing the depths of mental and sexual cruelty of which both men and women are capable.
The film focuses on three men and three women, who, while not alone in their world, are the only ones with speaking roles in the film. There's one married couple, one "together" couple, and two singles.
The married couple are Barry and Mary (Aaron Eckhart and Amy Brenneman), who, behind a happy facade, are having marital troubles. Mary simply wants something different... and that may mean Barry's best friend Jerry (Ben Stiller), who's having relationship problems of his own, with his girlfriend Terri (Catherine Keener).
Now, Terri is unsatisfied in her relationship with Jerry, and in fact seems to get more enjoyment out of her new friendship with an artist's assistant named Cheri (Nastassja Kinski). Meanwhile, the single womanizer Cary (Jason Patric) is on the prowl...and may just be true evil personified.
None of the characters have names in the film (until the end credits, where the rhyming nominations seem a further exercise in anonymity). This serves to put a more personal spin on the whole movie...after all, they are "Your" Friends and Neighbors.
But they're not people you'd really like to get that close to. Seemingly normal on the outside, each and every one is a flawed specimen of humanity. Or are they the status quo? (Shudder.) In either case, you're simultaneously repulsed yet riveted to the screen.
Jason Patric and Catherine Keener are the standouts in a talented cast, and also the creepiest of the bunch. Of the six, only Nastassja Kinski's character is never fully explored...and she actually turns out to be the nicest one here. Perhaps LaBute has problems writing for normal people.
Your Friends and Neighbors is never as sharp as his In the Company of Men, but it comes close, and is a more ambitious undertaking. LaBute's sophomore slump here is only slight.
This is not a date movie. It is fascinating to watch, but does little to enhance a harmonious relationship. In fact, it is the type of movie that makes you want to shun any and all human contact whatsoever.
Copyright 1998 Matt Williams
- Matt Williams<EMAIL_ADDRESS>Reviewer for Cinematter: http://www.cinematter.com Home of over 600 reviews, and information on nearly 700 upcoming releases
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