m.deferred
- Usage
- Retrieving a value via the getter-setter API
- Integrating to the Mithril redrawing system
- Differences from Promises/A+
- The exception monitor
- Signature
This is a low-level method in Mithril. It's a modified version of the Thenable API.
A deferred is an asynchrony monad. It exposes a promise
property which can bind callbacks to build a computation tree.
The deferred object can then apply a value by calling either resolve
or reject
, which then dispatches the value to be processed to the computation tree.
Each computation function takes a value as a parameter and is expected to return another value, which in turns is forwarded along to the next computation function (or functions) in the tree.
The deferred object returned by m.deferred
has two methods: resolve
and reject
, and one property called promise
. The methods can be called to dispatch a value to the promise tree. The promise
property is the root of the promise tree. It has a method then
which takes a successCallback
and a errorCallback
callbacks. Calling the then
method attaches the computations represented by successCallback
and errorCallback
to the promise, which will be called when either resolve
or reject
is called. The then
method returns a child promise, which, itself, can have more child promises, recursively.
The promise
object is actually a function - specifically, it's an m.prop
getter-setter, which gets populated with the value returned by successCallback
if the promise is resolved successfully.
Note that Mithril promises are not automatically integrated to its automatic redrawing system. If you wish to use third party asynchronous libraries (for example, jQuery.ajax
), you should also consider using m.startComputation
/ m.endComputation
if you want views to redraw after requests complete.
Usage
//standalone usage
var greetAsync = function() {
var deferred = m.deferred();
setTimeout(function() {
deferred.resolve("hello");
}, 1000);
return deferred.promise;
};
greetAsync()
.then(function(value) {return value + " world"})
.then(function(value) {console.log(value)}); //logs "hello world" after 1 second
Retrieving a value via the getter-setter API
The promise object is actually a getter-setter function that gets populated when the promise is fulfilled.
//asynchronous service
var greetAsync = function() {
var deferred = m.deferred();
setTimeout(function() {
deferred.resolve("hello");
}, 1000);
return deferred.promise;
};
//asynchronous consumer
var greeting = greetAsync()
var processed = greeting.then(function(value) {return value + " world"})
console.log(greeting()) // undefined - because `deferred.resolve` has not been called yet
setTimeout(function() {
//now `deferred.resolve` has been called
console.log(greeting()) // "hello"
console.log(processed()) // "hello world"
}, 2000)
Integrating to the Mithril redrawing system
By default, promises are not integrated to the Mithril auto-redrawing system. When dealing with asynchronous functions, you must call [m.startComputation
/ m.endComputation
] if you want the asynchronous payload to affect the view.
//asynchronous service
var greetAsync = function() {
//tell Mithril to wait for this service to complete before redrawing
m.startComputation();
var deferred = m.deferred();
setTimeout(function() {
deferred.resolve("hello");
//the service is done, tell Mithril that it may redraw
m.endComputation();
}, 1000);
return deferred.promise;
};
Some cases may not require a redraw upon completion of the asynchronous callbacks. In such cases, simply omit the m.startComputation/m.endComputation calls.
Some asynchronous operations might need to affect redrawing both before and after their completion. In those cases, you can call m.redraw
instead of using m.startComputation/m.endComputation.
//asynchronous service
var greetAsync = function() {
//don't wait for this service; redraw right away
var deferred = m.deferred();
setTimeout(function() {
deferred.resolve("hello");
//redraw again
m.redraw()
}, 1000);
return deferred.promise;
};
Differences from Promises/A+
For the most part, Mithril promises behave as you'd expect a Promise/A+ promise to behave, but have one difference: Mithril promises attempt to execute synchronously if possible.
Synchronous execution
Mithril promises attempt to execute synchronously if possible. To illustrate the difference between Mithril and A+ promises, consider the code below:
var deferred = m.deferred()
deferred.promise.then(function() {
console.log(1)
})
deferred.resolve("value")
console.log(2)
In the example above, A+ promises are required to log 2
before logging 1
, whereas Mithril logs 1
before 2
. Typically resolve
/reject
are called asynchronously after the then
method is called, so normally this difference does not matter.
There are a couple of reasons why Mithril runs callbacks synchronously. Conforming to the spec requires either a setImmediate
polyfill (which is a significantly large library), or setTimeout
(which is required to take at least 4 milliseconds per call, according to its specs). Neither of these trade-offs are acceptable, given Mithril's focus on nimbleness and performance.
Unchecked Error Handling
By default, Mithril does not swallow errors if these errors are subclasses of the Error class. Manually throwing an instance of the Error class itself (or any other objects or primitives) does trigger the rejection callback path as per the Promises/A+ spec.
This deviation from the spec is there to make it easier for developers to find common logical errors such as typos that lead to null reference exceptions. By default, the spec requires that all thrown errors trigger rejection, which result in silent failures if the developer forgets to explicitly handle the failure case.
For example, there is simply never a case where a developer would want to programmatically handle the error of accessing the property of a nullable entity without first checking for its existence. The only reasonable course of action to prevent the potential null reference exceptions in this case is to add the existence check in the source code. It is expected that such an error would bubble up to the console and display a developer-friendly error message and line number there.
m.request({method: "GET", url: "/things"})
.then(function(items) {
item.foreach(doSomething) //programmer error: typo will throw runtime error to the console
})
The other side of the coin is still supported: if a developer needs to signal an exceptional condition within a promise callback, they can manually throw a new Error
(for example, if a validation rule failed, and there should be an error message displayed to the user).
var error = m.prop()
m.request({method: "GET", url: "/user/:id", data: {id: 1}})
.then(function(user) {
if (!user.isAdmin) throw new Error("Sorry, you don't have permissions")
})
.then(null, error) //handle the application error: bind to a getter-setter for diplaying it on the template
Note that the default promise exception handling semantics can be modified. See the next section.
The exception monitor
Any time an exception is thrown inside a promise callback, Mithril calls m.deferred.onerror(e)
.
By default, this event handler rethrows the exception to the console if an error is a subclass of Error (but not an instance of Error itself). Otherwise it follows the Promises/A+ specifications. It does this because people expect unexpected errors like null reference exceptions to be thrown to the console for debugging purposes, and these errors are always subclasses of Error.
On the other hand, javascript developers rarely ever throw errors that are subclasses of Error, and for the purposes of application error handling, the underlying prototypal chain of the error class is typically not relevant.
The onerror
function can be safely replaced if the default error monitoring semantics are not desired.
//swallow all errors
m.deferred.onerror = function() {}
//only log errors
m.deferred.onerror = function(e) {console.error(e)}
Signature
Deferred deferred() {void onerror(Error e)}
where:
Deferred :: Object { Promise promise, void resolve(any value), void reject(any value) }
Promise :: GetterSetter { Promise then(any successCallback(any value), any errorCallback(any value)), Promise catch(any errorCallback(any value)) }
GetterSetter :: any getterSetter([any value])
GetterSetter { Promise then([any successCallback(any value) [, any errorCallback(any value)]]) } promise
A promise has a method called
then
which takes two computation callbacks as parameters.The
then
method returns another promise whose computations (if any) receive their inputs from the parent promise's computation.A promise is also a getter-setter (see
m.prop
). After a call to eitherresolve
orreject
, it holds the result of the parent's computation (or theresolve
/reject
value, if the promise has no parent promises)Promises also have a method called
catch
, which is equivalent to callingthen(null, errorCallback)
Promise then([any successCallback(any value) [, any errorCallback(any value)]])
This method accepts two callbacks which process a value passed to the
resolve
andreject
methods, respectively, and pass the processed value to the returned promiseany successCallback(any value) (optional)
The
successCallback
is called ifresolve
is called in the rootdeferred
.The default value (if this parameter is falsy) is the identity function
function(value) {return value}
If this function returns undefined, then it passes the
value
argument to the next step in the thenable queue, if anyany errorCallback(any value) (optional)
The
errorCallback
is called ifreject
is called in the rootdeferred
.The default value (if this parameter is falsy) is the identity function
function(value) {return value}
If this function returns undefined, then it passes the
value
argument to the next step in the thenable queue, if anyreturns Promise promise
void resolve(any value)
This method passes a value to the
successCallback
of the deferred object's child promisevoid reject(any value)
This method passes a value to the
errorCallback
of the deferred object's child promise-
m.deferred.onerror
void onerror(Error e)
This method gets called every time an exception is thrown inside a promise callback. By default, it rethrows to the console if an error is a subclass of Error (but not an instance of Error itself). Otherwise it follows the Promises/A+ specifications.


Standard Development Vs WCAG Compliant Development
While standard development may be more inexpensive in comparison, WCAG compliance is integral in building a website that emphasizes accesibility for all visitors including those with disabilities. Compliance with WCAG guidelines is necessary in order to avoid potential lawsuits and/or government action when building your business.
Perceivable
Text Alternatives, Adaptable, Distinguishable
Operable
Functionality, Assistance, Purpose
Understandable
Readable, Predictable, Consistent
Compatible
Identifiable, Navigatable, Accessible
How It Works
While building a website may not be the most difficult aspect of creating a business, becoming WCAG (AA) compliant requires rigourous testing and research in order to uphold the standard sought out by so many websites today. Our team of dedicated developers at Blue Squad will build your business site from scratch, and test every possible user interaction within it's contents to ensure it is WCAG Compliant and up to par with industry leaders. Our goal is to help you provide complete access to your website for all potential clients.
Recent News
2 Ways to Be Economical When Showering With an Injury
It’s extremely challenging to lead your daily life while sustaining an injury. And yet, dealing with sports injuries is something that most of us will have to go through, with nearly 2 million sports-related injuries affecting high school athletes alone per year. Most of us know the feeling of attempting to take a shower or bath when your arm is wrapped in a cast and cannot get wet. It’s a defeated feeling, and it can quickly take away the motivation to shower or bathe in the first place.
Don’t Put These Things Down The Shower Drain!
Natural water in Finland is some of the most polluted water in Europe (read the discussions in the article). You might be contributing to its pollution without realizing it, such as if you’re putting things down the drain that you really shouldn’t. Making your shower eco-friendly should be about saving water as well as preventing water contamination. Here’s what you can do to be greener and cleaner! In Finland, people use an average of 140 liters of water every day.


Penang Man Handles Dangerous Jellyfish With His Bare Hands And Gives Tips If You Are Stung
by Fadzly HanaffiTap to listen to this article instead: 🔊 Listen to Post
For those who frequent the beach, it’s possible that you may not come upon a smack of jellyfish but be warned that some beach side hotels will alert its residences when it’s jellyfish season, to avoid the risk of being poisoned by one.
Though most jellyfish stings are not dangerous, be warned that the powerful venom it releases hurt like hell, and if left untreated can be dangerous or even deadly.
Very different from what is mentioned by Spongebob and Patrick right?
Penang Kini shared a video recorded by a netizen about Abang Siva, a jellyfish ‘specialist’ of some sort sharing tips on what you should do when you come across the creature.
Here is a video of him sharing handy tips when handling jellyfish.
“When we were having a chat he spotted a jellyfish nearby and caught it.”
“The hotel did inform us that it is now jellyfish season and we did not think that it would be this close to shore.”
“Here is what Siva had to say – to hold a jellyfish be sure to use the palm of your hands and not close to your skin at the back, that’s when you risk getting stung.”
He mentions that it is important to let the jellyfish dry in the sun and bury it in the sand instead of throwing it back into the ocean, putting others at risk of being stung.
The netizen shared that Siva has been living by the seaside since he was 12 and has been stung a few times before.
Siva mentions “There are two types of jellyfish here (Penang). The white one is not as dangerous. When they sting spots will appear and you will feel itchy/pain from 30 minutes to an hour.”
“One way of overcoming the pain is by applying vinegar or piss.”
That is the least dangerous of the two.
“The second one is the transparent jellyfish. Should you come across one, it will latch itself to your flesh and if it is not ripped off it may make its way to your bones.”
Seriously, WTF!
“Once you are able to detach it from your limb, rush to the hospital and get treatment as it may be fatal.”
Useful tips don’t you think?
Be wary of the warning signs given by authorities when you are at the beach. It pays to be a little more careful especially when there are kids around.
Also read: Patrol Boat Unexpectedly Sees an ELEPHANT Stranded in The Ocean


class Solution: def maxAverageRatio(self, classes: List[List[int]], k: int) -> float: heap = [] for a, b in classes: heapq.heappush(heap, (a/b - (a + 1) / (b + 1), a, b)) for _ in range(k): rt, a, b = heapq.heappop(heap) heapq.heappush(heap, ((a + 1) / (b + 1) - ((a + 2) / (b + 2)), a + 1, b + 1)) ret = 0.0 for rt, a, b in heap: ret += a / b return ret / len(classes)


An Introduction to Word Embeddings - Part 2: Problems and Theory
In the previous post, we introduced what word embeddings are and what they can do. This time, we’ll try to make sense of them. What problem do they solve? How can they help computers understand natural language?
Understanding
See if you can guess what the word wapper means from how it’s used in the following two sentences:
- After running the marathon, I could barely keep my legs from wappering.
- Thou’ll not see Stratfort to-night, sir, thy horse is wappered out. (Or perhaps a more modern take: I can’t drive you to Stratford tonight for I’m wappered out).
The second example is from the Oxford English Dictionary entry. If you haven’t guessed, the word was probably more popular in the late-19th century. But it means to shake, especially from fatigue (and it might share the same linguistic roots as to waver).
By now, you likely have a pretty good understanding of what to wapper means, if you like, even creating new sentences. Impressively, you probably didn’t need me to explicitly tell you the definition; indeed, how many words in this sentence did you learn by reading a dictionary entry? We learn what words mean from their surrounding contexts.
This implies that even though it appears that the meaning of a word is intrinsic to the word, some of the meaning of a word also exists in its context.
Words, like notes on an instrument, do have their individual tones. But it is their relationship with each other—their interplay—that gives way to fuller music. Context enriches meaning.
So, take a context,
After running the marathon, I could barely keep my legs from ____________.
We should have a sense of what words could fill the blank. Much more likely to appear are words like shaking, trembling, and of course, wappering. Especially compared to nonsense like pickled, big data, or even pickled big data.
In short, the higher probability of appearing in this context corresponds to greater shared meaning. From this, we can deduce the distributional hypothesis: words that share many contexts tend to have similar meaning.
What does this mean for a computer trying to understand words?
Well, if it can estimate how likely a word is to appear in different contexts, then for most intents and purposes, the computer has learned the meaning of the word.1 Mathematically, we want to approximate the probability distribution of
Then, the next time the computer sees a specific context $c$, it can just figure out which words have the highest probability of appearing, $p( word | c )$.
Challenges
The straightforward and naive approach to approximating the probability distribution is:
- step 1: obtain a huge training corpus of texts,
- step 2: calculate the probability of each (word,context) pair within the corpus.
The underlying (bad) assumption? The probability distribution learned from the training corpus will approximate the theoretical distribution over all word-context pairs.
However, if we think about it, the number of contexts is so great that the computer will never see a vast majority of them. That is, many of the probabilities $p( word | c )$ will be computed to be 0. This is mostly a terrible approximation.
The problem we’ve run into is the curse of dimensionality. The number of possible contexts grows exponentially relative to the size of our vocabulary—when we add a new word to our vocabulary, we more or less multiply the number of contexts we can make.2
We overcome the curse of dimensionality with word embeddings, otherwise known as distributed representations of words. Instead of focusing on words as individual entities to be trained one-by-one, we focus on the attributes or features that words share.
For example, king is a noun, singular and masculine. Of course, many words are masculine singular nouns. But as we add more features, we narrow down on the number of words satisfying each of those qualities.
Eventually, if we consider enough features, the collection of features a word satisfies will be distinct from that of any other word.3 This lets us uniquely represent words by their features. As a result, we can now train features instead of individual words.4
This new type of algorithm would learn more along the lines of in this context, nouns having such and such qualities are more likely to appear instead of we’re more likely to see words X, Y, Z. And since many words are nouns, each context teaches the algorithm a little bit about many words at once.
In summary, every word we train actually recalls a whole network of other words. This allows us to overcome the exponential explosion of word-context pairs by training an exponential number of them at a time.5
A New Problem
In theory, representing words by their features can help solve our dimensionality problem. But, how do we implement it? Somehow, we need to be able to turn every word into a unique feature vector, like so:
But features like is a word isn’t very helpful; it doesn’t contribute to forming a unique representation. One way to ensure uniqueness is by looking at a whole lot of specific features.  That way, every word definitely corresponds to a different feature vector:
This isn’t a great representation though. Not only is this a very inefficient way to represent words, but it also fails to solve the original dimensionality problem. Although every word still technically recalls a whole network of words, each network contains only one word!
Constructing the right collection of features is a hard problem. They have to be not too general, not too specific. The resulting representation of each word using those features should be unique. And, we should limit the number of features to between 100-1000, usually.
Furthermore, even though it’s simpler to think about binary features that take on True/False values, we’ll actually want to allow a spectrum of feature values. In particular, any real value. So, feature vectors are also actually vectors in a real vector space.
A New Solution
The solution to feature construction is: don’t. At least not directly.6
Instead, let’s revisit the probability distributions from before:
This time, words and contexts are represented by feature vectors:
which are just a collection of numbers. This turns the probability distributions from a functions over categorical objects (i.e. individual words) into a function over numerical variables θijθij. This is something that allows us to bring in a lot of existing analytical tools—in particular, neural networks and other optimization methods.
The short version of the solution: from the above probability distributions, we can calculate the probability of seeing our training corpus, p(corpus)p(corpus), which had better be relatively large. We just need to find the values for each of the $\theta_{ij}$’s that maximize p(corpus)p(corpus).
These values for $\theta_{ij}$ give precisely the feature representations for each word, which in turn lets us calculate $p( word | context )p( word | context )$.
Recall that this in theory teaches a computer the meaning of a word!
A Bit of Math
In this section, I’ll give enough details for the interested reader to go on and understand the literature with a bit more ease.
Recall from previously, we have a collection of probability distributions that are functions over some $\theta_{ij}$’s. The literature refers to these $\theta_{ij}$’s as parameters of the probability distributions $p(w|c)$ and $p(c|w)$. The collection of parameters $\theta_{ij}$’s is often denoted by a singular θθ, and the parametrized distributions by $p(w|c;\theta)$ and $p(c|w;\theta)$.7
If the goal is to maximize the probability of the training corpus, let’s first write $p(\textit{corpus};\theta)$ in terms of $p(c|w;\theta)$.
There are a few different approaches. But in the simplest, we think of a training corpus as an ordered list of words, $w^1,w2, \cdots ,w^T$. Each word in the corpus wtwt has an associated context $C_t$, which is a collection of surrounding words.
Diagram 1. A corpus is just an ordered list of words. The context CtCt of wtwt is a collection of words around it.8
For a given word $w_t$ in the corpus, the probability of seeing another word $w_c$ in its context is $p(w_c | w_t;\theta)$. Therefore, the probability that a word sees all of the surrounding context words $w_c$ in the training corpus is
To get the total probability of seeing our training corpus, we just take the product over all words in the training corpus. Thus,
Now that we have the objective function, $f(\theta)=p(\textit{corpus};\theta)$, it’s just a matter of choosing the parameters $\theta$ that maximize $f$.9 Depending on how the probability distribution is parametrized by $\theta$, this optimization problem can be solved using neural networks. For this reason, this method is also called a neural language model (NLM).
There are actually more layers of abstraction and bits of brilliance between theory and implementation. While I hope that I’ve managed to give you some understanding on where research is proceeding, the successes of the current word embedding methods are still rather mysterious. The intuition we’ve developed on the way is still, as Goldberg, et. al. wrote, “very hand-wavy” (Goldberg 2014).
Still, perhaps this can help you have some intuition for what’s going on behind all the math when reading the literature. A lot more has been written on this subject too; you can also take a look below where I list more resources I found useful.
Resources
I focused mainly on word2vec while researching neural language models. However, do keep in mind that word2vec was just one of the earlier and possibly more famous models. To understand the theory, I quite liked all of the following. Approximately in order of increasing specificity,
- Radim Řehůřek’s introductory post on word2vec. He also wrote and optimized the word2vec algorithm for Python, which he notes sometimes exceeds the performance of the original C code.
- Chris McCormick’s word2vec tutorial series, which goes into much more depths on the actual word2vec algorithm. He writes very clearly, and he also provides a list of resources.
- Goldberg and Levy 2014, word2vec Explained, which helped me formulate my explanations above.
- Sebastian Ruder’s word embedding series. I found this series comprehensive but really accessible.
- Bojanowski 2016, Enriching word vectors with subword information. This paper actually is for Facebook’s fastText (which Mikolov is a part of), but it is based in part on word2vec. I found the explanation of word2vec’s model in Section 3.1 transparent and concise.
- Levy 2015, Improving distributional similarity with lessons learned from word embeddings points out that actually, the increased performance of word2vec over previous word embeddings models might be a result of “hyperparameter optimizations,” and not necessarily in the algorithm itself. Expand here to see the he references I cited above
References
- (Bengio 2003) Bengio, Yoshua, et al. “A neural probabilistic language model.” Journal of machine learning research 3.Feb (2003): 1137-1155.
- (Bojanowski 2016) Bojanowski, Piotr, et al. “Enriching word vectors with subword information.” arXiv preprint arXiv:1607.04606 (2016).
- (Goldberg 2014) Goldberg, Yoav, and Omer Levy. “word2vec Explained: deriving Mikolov et al.’s negative-sampling word-embedding method.” arXiv preprint arXiv:1402.3722 (2014).
- (Goodfellow 2016) Goodfellow, Ian, Yoshua Bengio, and Aaron Courville. Deep learning. MIT press, 2016.
- (Hamilton 2016) Hamilton, William L., et al. “Inducing domain-specific sentiment lexicons from unlabeled corpora.” arXiv preprint arXiv:1606.02820 (2016).
- (Kusner 2015) Kusner, Matt, et al. “From word embeddings to document distances.” International Conference on Machine Learning. 2015.
- (Levy 2015) Levy, Omer, Yoav Goldberg, and Ido Dagan. “Improving distributional similarity with lessons learned from word embeddings.” Transactions of the Association for Computational Linguistics 3 (2015): 211-225.
- (Mikolov 2013a) Mikolov, Tomas, Wen-tau Yih, and Geoffrey Zweig. “Linguistic regularities in continuous space word representations.” hlt-Naacl. Vol. 13. 2013.
- (Mikolov 2013b) Mikolov, Tomas, et al. “Efficient estimation of word representations in vector space.” arXiv preprint arXiv:1301.3781 (2013).
- (Mikolov 2013c) Mikolov, Tomas, et al. “Distributed representations of words and phrases and their compositionality.” Advances in neural information processing systems. 2013.
- (Mikolov 2013d) Mikolov, Tomas, Quoc V. Le, and Ilya Sutskever. “Exploiting similarities among languages for machine translation.” arXiv preprint arXiv:1309.4168 (2013).
- (Mnih 2012) Mnih, Andriy, and Yee Whye Teh. “A fast and simple algorithm for training neural probabilistic language models.” arXiv preprint arXiv:1206.6426 (2012).
- (Rong 2014) Rong, Xin. “word2vec parameter learning explained.” arXiv preprint arXiv:1411.2738 (2014).
Foot note
- And let's not get into any philosophical considerations of whether the computer really understands the word. Come to think of it, how do I even know you understand a word of what I'm saying? Maybe it's just a matter of serendipity that the string of words I write make sense to you. But here I am really talking about how to oil paint clouds, and you think that I'm talking about machine learning ↩
- Consider a 20-word context. If we assume that the average English speaker's vocabulary is 25,000 words, then the increase of 1 word corresponds to an increase of about $7.2 e 84$ contexts, which is actually more than the number of atoms in the universe. Of course, most of those contexts wouldn't make any sense. ↩
- The algorithm used by the Google researchers mentioned above assumes 300 features.↩
- The term distributed representation of words comes from this: we can now represent words by their features, which are shared (i.e. distributed) across all words. We can imagine the representation as a feature vector. For example, it might have a ‘noun bit' that would be set to 1 for nouns and 0 for everything else. This is, however, a bit simplified. Features can take on a spectrum of values, in particular, any real value. So, feature vectors are actually vectors in a real vector space. ↩
- The distributed representations of words "allows each training sentence to inform the model about an exponential number of semantically neighboring sentences," (Bengio 2003). ↩
- This also means that there's probably not a ‘noun bit' in our representation, like in the figures above. There might not be any obvious meaning to each feature. ↩
- The softmax function is often chosen as the ideal probability distribution. ↩
- One can control the algorithm by specifying different hyperparameters: do we care about order of words? How many surrounding words do we consider? And on. ↩
- ↩
Remark
This blog content is requested by Gautam Tambay and edited by Jun Lu.


Big Screen
I bought a wire of HDMI to DVI last night. So now my mac can connect to the big screen. Macbook’s Retina screen is »
I bought a wire of HDMI to DVI last night. So now my mac can connect to the big screen. Macbook’s Retina screen is »
I am in the library now. There’s a woman who’s playing online card games in the computer of library. How can people »
Honestly, I am not very good at javascript, I know how to use jQuery and watch some videos about ES6. I had learned AngularJs on codecademy »
Now I am free finally. All the procedure is over, I do not want to comment, it’s good to leave quietly. I didn’ »
有的时候是要遇到一些这样的人，他们让你看到人性的恶。让你知道这个世界并不那么美好，他们利用你的善良，自以为聪明地可以操纵你。 世界不那么美好，但也不要从此就认为世界都是黑暗。这种动物带来的影响，是让你更加珍惜拥有的真诚。 千万不要掉到钱坑里面去，那些满脑子功利的人，不可能保持一颗单纯敏感的心。君子爱财，取之有道。真正自信的人，不会害怕失败。但为了金钱丢了人格尊 »
This is not a tech blog. I write what I thought about life, and practise English here. When I update my github project, I found that& »
Are they thinking I am showing off? Maybe their feeling is right, sometimes I do :-) I like to share, especially when I find something cool, »
Today I went to dinner with XiaoYa, and watched movie with her after that. The movie is called "The Legend of Tarzan", a typical Hollywood movie. »
It taks a while to open this site. The Internet environment in China is becoming worse and worse. It’s a tragedy that we close »
This afternoon I went to attend google develop group activity with Sammy. The topic was about VR and AR. Honestly say, the process was kinda boring. »


Sometimes, a chapter in a book, or an episode in a TV series, or a part in another type of work, shares its title with the work itself.
This often happens with the last chapter, episode or part. One of the reasons is that the title works as indication that the road is now complete, for example, if an essay's title refers to the main idea it's trying to prove, the last chapter would have the same title because all the arguments have been presented and now the conclusion represents the whole book, similarly to a fractal, where a part is identical to the whole.
Quite as often, as well, it's the first episode or part which bears the same title as the whole work. This is because the segment serves as introduction to the main character, setting, or idea of the work. In the case of TV shows, the reason may be that the first episode was originally made as the pilot for the whole series, so it's natural that it bears the same name.
Another reason to use this may be that the title of the work as a whole is part of a phrase, song lyric, poem, etc. that is divided among the chapter titles (i.e., a Compound Title). In this case, the partial titles are also Arc Words.
Subtrope of Title Drop. Sometimes related to Compound Title and Arc Words.
Examples
- Attack on Titan: It doesn't quite work in English, but the Japanese version has a direct example. Chapter 88 is called Shingeki no Kyojin, or The Attack Titan in English. It refers to the name of Eren Yeager's titan itself, who the series is named after. This chapter also features the reveal of the titan's name, which is said by Eren as he's recalling his father's memories.
- Darker Than Black: The final episode of the first season is entitled '"Does the Reaper Dream of Darkness Darker than Black?"
- Jojos Bizarre Adventure: The final arc of Part 4: Diamond is Unbreakable, is an odd example as both Part 4 's title and it's chapters names were retroactively changed later when published as tankobon. Part 4 went from being called simply 'Josuke Higashikata' to 'Diamond is Unbreakable', and the final arc is collected as 'Crazy Diamond is Unbreakable'
- Kaguya-sama: Love Is War: While not used for the series as a whole, the final chapter of "The First Kiss Never Ends" arc shares its name.
- Naruto: Both the first chapter and the last chapter are simply named 'Uzumaki Naruto' with the second having two exclamation points instead of one.
- Sound! Euphonium: "Sound! Euphonium" is the title of book 3's final chapter (not including the epilogue), and of season 2 episode 9.
- The Tower of God anime's first season's last episode is called "Tower of God". It's based more on the logic of first episodes being called that than last ones, since more than anything being completed here, the first season just set up the stage for the long, long story from the comic.
- Legacy (Total Drama): The final chapter is titled "Legacy". This chapter elaborates on the titular legacy, revealed in the previous chapter's closing Wham Line.
- While the first film in the Star Wars franchise was later retroactively titled A New Hope in order to distinguish it from the name of the franchise itself, it was originally released and marketed as, and is still often colloquially referred to as, simply Star Wars.
- Silent film The Ace of Hearts is divided into ten chapters. Chapter 3 is called "The Ace of Hearts", and is the one where the terrorists draw cards. Forrest winds up drawing the ace of hearts and thus is tasked with the assassination.
- The Call of the Cumberlands: In this silent film, a hillbilly named Samson leaves Appalachia to go to New York to study art. The scene where he gets a letter telling him that war has broken out between the Feuding Families back home is proceeded by a title card that says "The Call of the Cumberlands".
- The seventh and final (not counting an interquel that came out later) book in Stephen King's The Dark Tower series is titled The Dark Tower.
- Chapter 11 of The Shining, book 3 of The Stand, part 11 of Firestarter, chapter 51 of ChrisTine and part 2 of Misery are the same as their book's title.
- Moby-Dick. When Moby Dick, the legendary whale, finally appears in chapter 41 of the eponymous book after much anticipation, the chapter pays service to this fact by bearing the title "Moby-Dick".
- The second and last part of Eric-Emmanuel Schmitt's The Gospel According To Pilate is titled "The Gospel according to Pilate".
- All Harry Potter books except for the first and the third have one chapter that bears the same title as the book itself.
- "The Chamber of Secrets" (chapter 16) sees Harry and Ron enter the Chamber and end up separated before Harry learns the identity of the Heir of Slytherin and the chapter ends.
- "The Goblet of Fire" (chapter 16) unveils the titular cup and describes the excitement over who it will choose to enter the Triwizard Tournament. Three champions are chosen before an unprecedented fourth emerges from the malfunctioning Goblet: Harry Potter.
- "The Order of the Phoenix" (chapter 5) provides Harry and the audience a hefty amount of exposition on the Order and its role in resisting Voldemort.
- "The Half-Blood Prince" (chapter 9) starts immediately after the first Title Drop and begins Harry's obsession with the Prince.
- "The Deathly Hallows" (chapter 22) occurs two chapters after the Hallows are introduced, and hardly includes any of them. It is instead named as such because the chapter sees the height of Harry's obsession with them. This obsession makes him careless and gets him captured, which snowballs into the death of the innocent, downtrodden Dobby.
- Isaac Asimov:
- In the novel The Gods Themselves, the second of the three parts is titled "The Gods Themselves". The three titles form a quotation that is the epigraph of the whole book.
- Foundation (1951): The first Novella was initially published as "Foundation". When publishing this Novel, Dr Asimov renamed the chapter to "The Encyclopedists" and deliberately avoided sharing a chapter title with the book's title.
- Italo Calvino's If on a winters night a traveler. The first chapter is titled "If on a Winter's Night a Traveler" and the other chapters continue the sequence, forming a coherent text.
- When Jules Verne wrote Michael Strogoff, he decided to use the name of the protagonist as the title for both the first chapter and the book as a whole.
- Mystery novels by Michael Connelly:
- The last part of The Fifth Witness, which includes the climax in which Mickey Haller gets his client off and then figures out who was the murderer, is called "The Fifth Witness".
- The last part of Echo Park, in which Bosch sets up a sting to nab the real killer of Marie Gesto, is called "Echo Park".
- The last chapter of The Scarecrow, a brief epilogue that recounts Carver's grim And I Must Scream fate, is titled "The Scarecrow".
- The last part of The Gods of Guilt, which is basically an epilogue tying up the loose ends after the story has been resolved, is called "The Gods of Guilt".
- Discworld Tiffany Aching novels:
- Chapter 4 of The Wee Free Men, where the Feegles make their first full appearance, is called "The Wee Free Men".
- Chapter 15 of A Hat Full of Sky, which reiterates the metaphor, is called "A Hat Full of Sky".
- Chapter 18 of The Shepherd's Crown, which is the big climax where Tiffany reasserts her connection to the land, is called "The Shepherd's Crown".
- Nonfiction example: Life Is with People, a work of sociology about the culture of the Jewish shtetls, has a chapter in the middle called "Life Is with People."
- Ella Minnow Pea is divided into sections headed by the ever-diminishing list of alphabet letters still legal to use. Considering the titular protagonist's Punny Name, it's not hard to foresee the arrival of a chapter headed by ***LMNOP***, those being the very last letters remaining after the rest are banned.
- The third to last chapter of The Sight is called "The Sight".
- The Beast Player: The series has the same title as the last chapter of the original duology and the last episode of the anime.
- The pilot/first episode for Logan's Run is titled "Logan's Run".
- Babylon 5: Each season has a season name taken from an episode in that season which fundamentally alters the direction the show had been taking up to that point.
- Season 1: Signs and Portents
- Season 2: The Coming of Shadows
- Season 3: Point of No Return
- Season 4: No Surrender, No Retreat
- Season 5: The Wheel of Fire
- Inverted in the first two series of Doctor Who. The serials didn't have titles back then, so they were retroactively titled by the first episode of the serial.
- "An Unearthly Child" is the first episode and serves as the title for the first serial.
- "The Edge of Destruction" consists of two episodes, "The Edge of Destruction" and "The Brink of Disaster."
- The only official title ever given to the TV movie is "Doctor Who", although it's usually marketed as "Doctor Who: The Movie" to avoid confusion.
- Played with in How I Met Your Mother: S9E16 is named "How Your Mother Met Me".
- The first season finale of Daredevil (2015) is named "Daredevil" to mark Matt Murdock's transition from The Devil of Hell's Kitchen, a dangerous vigilante, to Daredevil, a full-on superhero.
- This is repeated with the finale of The Defenders (2017) to mark the main group of Matt Murdock, Jessica Jones, Luke Cage, and Danny Rand working together to fight the Hand.
- In BlazBlue, each game will have one of the characters' individual stories being titled after the game's subtitles (Calamity Trigger, Continuum Shift, Chronophantasma). The final chapter of the last game is named 'BLAZBLUE'.
- Danganronpa Another Episode: Ultra Despair Girls has its final chapter titled "Absolute Despair Girls", an accurate translation of the game's original title, "Zettai Zetsubou Shoujo".
- Dead Space. The final chapter is named Dead Space (which ironically takes place in a planet).
- Doom: A number of megawads have their last level named after the megawad's title itself. Examples include Hell Revealed, Hellcore, Hadephobia and No End in Sight.
- Eternal Senia: Hydrangea After The Rain: The subtitle, "Hydragea After The Rain", is the title of the last chapter, before the epilogue, seen in the "The Story So Far" menu.
- Etrian Odyssey Nexus has one that's Lost in Translation. The final main story Labyrinth is called Yggdrasil Labyrinth, referring to the Japanese title, Sekaiju no Meikyuu.
- Fate/stay night has chapters named after each of the routes, including the one named after the game itself.
- Etrian Odyssey Nexus has one that's Lost in Translation. The final main story Labyrinth is called Yggdrasil Labyrinth, referring to the Japanese title, Sekaiju no Meikyuu.
- Fire Emblem
- Chapter 6 of Fire Emblem: Shadow Dragon is named "Fire Emblem", as it's when Marth receives the titular MacGuffin.
- Chapter 5 of Fire Emblem: The Binding Blade is named "Fire Emblem", as it's when Roy receives the titular MacGuffin. Wait a minute. Chapter 21 of the same game is named "The Binding Blade", wherein Roy receives the titular Infinity +1 Sword. Also strangely played with in the name of the first Sidequest chapter being "The Blazing Blade", which ended up being the subtitle of the next game in the series, a prequel.
- Played with in Fire Emblem: The Sacred Stones, where the final chapter is called "Sacred Stone", because by that point, only one of the 5 Sacred Stones remains.
- Chapter 24 of Fire Emblem Awakening is named "Awakening". But only in the English version, in the original Japanese it was called "The Exalt's Successor".
- Grand Theft Auto III features a story mission titled "Grand Theft Auto". There is no particular significance to the content of the mission, as it simply involves delivering a few stolen cars to the player's employer.
- The final chapter of the first House of the Dead is simply "The House of the Dead".
- The House of the Dead: OVERKILL follows suit, with its final chapter being "Overkill".
- The Legend of Heroes: Trails in the Sky SC: The last of the game's Onscreen Chapter Titles drops the chapter and numbering scheme altogether, simply titled "Finale: Trails in the Sky".
- The final chapters of both The Longest Journey and Dreamfall: The Longest Journey are titled "The Longest Journey". Dreamfall's epilogue, meanwhile, is titled "Dreamfall".
- The eighth and final chapter of Paper Mario: The Thousand-Year Door is named "The Thousand-Year Door".
- Prince of Persia: Warrior Within includes a title for each part of the game in save files, as a way of indicating where you are. The last of these is "The Warrior Within."
- Red Dead Redemption II has one of its last missions simply be named "Red Dead Redemption".
- Slender: The Arrival. The final chapter is named The Arrival.
- The concluding chapter of Uncharted 4: A Thief's End is called "A Thief's End", reflecting both the end of Henry Avery's story at the hands of his second-in-command; and the definitive end of Nate's affairs in illegal adventures while escaping Libertalia with Sam and their friends.
- The last level of Z, is "Z".
- The first book of Kill Six Billion Demons is called Kill Six Billion Demons.
- Inverted in the reference books for the Rocky and Bullwinkle show. Since all later episodes of the serial have two names, some books assign the name of the entire arc to the first episode, since they would otherwise have no name. Hence the first segment of the first arc "Jet Fuel Formula" is referred to by some sources as "Jet Fuel Formula", with the second segment called "Bullwinkle's Ride or Goodbye Dollink", the gag from the end of the first segment.


|
Translating XML to Typesafe Config(Hocon) should translate empty Configurations |
0.002 |
|
Translating XML to Typesafe Config(Hocon) should translate basic types |
0.004 |
|
Translating XML to Typesafe Config(Hocon) should translate lists of basic types of objects |
0.002 |
|
Translating XML to Typesafe Config(Hocon) should translate lists of objects |
0.002 |
|
Translating XML to Typesafe Config(Hocon) should translate objects |
0.002 |
|
Translating XML to Typesafe Config(Hocon) should translate maps of basic types |
0.002 |
|
Translating XML to Typesafe Config(Hocon) should translate maps of objects |
0.003 |
|
Translating XML to Typesafe Config(Hocon) should translate properties |
0.002 |
|
Translating XML to Typesafe Config(Hocon) should translate archivers |
0.01 |
|
Translating XML to Typesafe Config(Hocon) should translate filesets |
0.007 |
|
Translating XML to Typesafe Config(Hocon) should translate resource transformers |
0.002 |
|
Translating XML to Typesafe Config(Hocon) should translate dependencies |
0.002 |
|
Translating Typesafe Config(Hocon) to XML should translate empty Configurations |
0.001 |
|
Translating Typesafe Config(Hocon) to XML should translate basic types |
0.001 |
|
Translating Typesafe Config(Hocon) to XML should translate lists of basic types of objects |
0.002 |
|
Translating Typesafe Config(Hocon) to XML should translate lists of objects |
0.002 |
|
Translating Typesafe Config(Hocon) to XML should translate objects |
0.002 |
|
Translating Typesafe Config(Hocon) to XML should translate maps of basic types |
0.001 |
|
Translating Typesafe Config(Hocon) to XML should translate maps of objects |
0.002 |
|
Translating Typesafe Config(Hocon) to XML should translate properties |
0.003 |
|
Translating Typesafe Config(Hocon) to XML should translate archivers |
0.005 |
|
Translating Typesafe Config(Hocon) to XML should translate filesets |
0.002 |
|
Translating Typesafe Config(Hocon) to XML should translate resource transformers |
0.001 |
|
Translating Typesafe Config(Hocon) to XML should translate dependencies |
0.002 |
|
Translating Json to Typesafe Config(Hocon) should translate empty Configurations |
0.001 |
|
Translating Json to Typesafe Config(Hocon) should translate basic types |
0.002 |
|
Translating Json to Typesafe Config(Hocon) should translate lists of basic types |
0.001 |
|
Translating Json to Typesafe Config(Hocon) should translate lists of objects |
0.001 |
|
Translating Json to Typesafe Config(Hocon) should translate objects |
0.001 |
|
Translating Json to Typesafe Config(Hocon) should translate maps of basic types |
0.001 |
|
Translating Json to Typesafe Config(Hocon) should translate maps of objects |
0.001 |
|
Translating Json to Typesafe Config(Hocon) should translate archivers |
0.002 |
|
Translating Json to Typesafe Config(Hocon) should translate filesets |
0.001 |
|
Translating Json to Typesafe Config(Hocon) should translate resource transformers |
0.001 |
|
Translating Json to Typesafe Config(Hocon) should translate dependencies |
0 |
|
Translating Typesafe Config(Hocon) to Json should translate empty Configurations |
0 |
|
Translating Typesafe Config(Hocon) to Json should translate basic types |
0.002 |
|
Translating Typesafe Config(Hocon) to Json should translate lists of basic types of objects |
0.001 |
|
Translating Typesafe Config(Hocon) to Json should translate lists of objects |
0.001 |
|
Translating Typesafe Config(Hocon) to Json should translate objects |
0.001 |
|
Translating Typesafe Config(Hocon) to Json should translate maps of basic types |
0.001 |
|
Translating Typesafe Config(Hocon) to Json should translate maps of objects |
0.002 |
|
Translating Typesafe Config(Hocon) to Json should translate properties |
0.002 |
|
Translating Typesafe Config(Hocon) to Json should translate archivers |
0.003 |
|
Translating Typesafe Config(Hocon) to Json should translate filesets |
0.001 |
|
Translating Typesafe Config(Hocon) to Json should translate resource transformers |
0.001 |
|
Translating Typesafe Config(Hocon) to Json should translate dependencies |
0.001 |


{ "title": "Frontend setup", "html": { ".main-content": "
Custom data-ajaxify attribute is used to mark html elements that may be reloaded dynamically. The value of this attribute is a key of the html object in json response from server.


---
creation_epoch:<PHONE_NUMBER>
lastmod_epoch:<PHONE_NUMBER>
categories: ['Tech Tricks']
title: Linux System Rescue CD, Linksys WUSB54GC, Getting wireless to work
---
System Rescue CD version 1.3+
- Later versions already include the rt73 firmware
- It should work out of the box
- Use wpa_supplicant if you need WPA encryption
- Helpful commands
- iwlist
- iwconfig
- ifconfig wlan0 up
- wpa_passphrase SSID passphrase > /wpa.conf
- wpa_supplicant
System Rescue CD version 1.2 and before
- Download the rt73 firmware (one for Linksys WUSB54GC chipset) from http://www.ralinktech.com.tw/data/RT71W_Firmware_V1.8.zip
- Extract rt73.bin to /lib/firmware
- Unload the kernel driver with rmmod rt73usb
- Reload the kernel driver with modprobe rt73usb
- Configure the wireless card as usual with iwconfig
- If you need WPA use wpa_supplicant


"You are not a body with a soul.  - C.S. Lewis
Please contact Aurana using the form below for any product, booking, or workshop related questions. Thank you.


Hello, Alarm API
Launch Application at date
Application Id:
At date:
Period:
seconds
Launch Application after delay
Application Id:
After Delay:
seconds
Period:
seconds
Get alarm information
Alarm Id:
no alarm found
Remove alarm(s)
Alarm Id:


Tony Nese and his wife welcome baby boy
by WWE.comIt’s a huge day for Tony Nese as the Superstar welcomed his beautiful baby boy into the world on Friday! Eric Nese, who the proud new dad called “the future #PremierAthlete,” was born weighing 9 lbs. Join us in congratulating Tony Nese and his wife on the newest addition to their family.


Michael Avtonomoff
Home
Projects
Blog
About Me
Blog Entries
17. Cultural Blog - Conflict
16. Big O Complexity and Notation
15. Cheat Sheet: Hashes, Arrays, Strings, Integers
14. Cultural Blog - Affirmation and Stereotype Threat
13. Ruby Hashes vs Javascript Objects
12. Stereotype Threat
11. Technical Blog: Object-Oriented Programming vs Functional Programming
10. Cultural Blog: Pairing and Feedback
9. Classes and Your Bear RPG
8. The Scourge of Legacy Software
7. Enumerable Methods
6. Peer Pairing and You
5. Thinking Styles and Mindsets
4. Arrays and Hashes in Ruby
3. CSS Design
2. Chef's Kitchen
1. Gitty With Git


{% load i18n %}
{% trans "We're sorry but a server error has occurred. We've been notified and will look into it as soon as possible." %}


Let’s make some labels… with an API!
A web API exists if you want to make labels programmatically. The
sole endpoint is /stickers
which accepts
POST
requests containing an
application/json
body like:
{ "type": "LCRY-1700", "gridlines": false, "labels": [ { "text": "first label text", "copies": 1 }, { "text": "two of these, please", "copies": 2 }, { "barcode": "123456", "text": "Sample #123456", "copies": 1 } ] }
The label type
is required; values match the dropdown in
the web form. The gridlines
field is optional. For
each label object, the text
and copies
fields are required. The barcode
field is optional.
A successful response contains an application/pdf
body.
curl example
curl -fsS http://localhost:5000/stickers \ --header 'Content-type: application/json' \ --data '{ "type": "LCRY-1700", "gridlines": false, "labels": [ { "text": "first label text", "copies": 1 }, { "text": "two of these, please", "copies": 2 }, { "barcode": "123456", "text": "Sample #123456", "copies": 1 } ] }' \ --output labels.pdf


TrustedCoin wallet secures your funds with a 2-of-3 multisig. You hold two keys, so we can't move your funds without your permission.
Any time someone spends funds from your account, we send you an email and SMS with a link to cancel the transaction within 24 hours.
You can use this wallet without even entering two of your private keys on the same computer.
That way, even if you have a keylogger running on your machine, no one can steal your coins without giving you 24 hours to reverse.
This wallet demonstrates a reference implementation of a secure wallet built using TrustedCoin APIs. See GitHub repository: https://github.com/jseims/trustedcoin-web-wallet
If you're a developer interested in building client-side wallets (Windows, Mac, Android) secured by TrustedCoin APIs, please contact us


This is a demo html view loaded using the swig templating engine.
The title from the controller is {{ title }}


Ebay nears deal to sell Stubhub to Viagogo for $4bn
by Jessica ClarkEbay is reportedly close to selling ticket site Stubhub to Viagogo for around $4bn.
A deal could be announced as soon as today, according to the Wall Street Journal.
Read more: Ebay chief executive steps down
The auction site bought Stubhub for $310m in 2007, but in March this year launched a strategic review of its assets following pressure from activist investors Elliott Management and Starboard Value.
The strategic review focused on offloading the Stubhub business as well as Ebay Classifieds Group after Elliott said the company could more than double its market value if it restructured the business.
Meanwhile, Switzerland-based ticket reselling site Viagogo has faced accusations that touts are using its platform to sell second-hand tickets at massively inflated prices.
In July Google suspended the company from advertising on its exchange after receiving complaints from the Football Association, trade body UK Music and MPs.
The Competition and Markets Authority dropped legal action against Viagogo in September after the ticket reseller addressed its concerns about how information was presented to customers.
The complaint centred around the platform’s use of so-called hover text to display information such as ticket prices and refund deadlines.
The regulator also accused Viagogo of using misleading information, including stating that there were more tickets left on sale than were actually available.


Current version: {{ version }}
Get Distribute from the Python Package Index
Visit the Distribute project page


The FishEye component can be set to expand to the right, left or from the centre. In conjunction, you can specify if
you want the menu to expand up or down.
- The first FishEye opens to the right and expands up with a 200% zoom.
- The second FishEye opens to the left and expands down with a 150% zoom. We change the component's alignment
by putting it into a containing div and changing the alignment.
- The third FishEye opens from the centre and expands up with a 250% zoom. Again, we place the component
in a div to specify the alignment.


Limited Time Offer! Hurry Up
Take courses on your any device with our app & learn all time what you want. Just download & install & start to learn
1200 Students
1300 Students
1800 Students
1800 Students
1243 Students
325 Students
200 Students
Students Enrolled
Certified Trainer
Professional Courses
Take courses on your any device with our app & learn all time what you want. Just download & install & start to learn
Apply NowTake courses on your any device with our app & learn all time what you want. Just download & install & start to learn


|
jubilant-funicular
|
Go to the source code of this file.
Classes | |
| struct | nta::Glyph |
| represents what is essentially a sprite More... | |
| struct | nta::RenderBatch |
| stores information about batches of vertices with the same texture in a vertex buffer object More... | |
| class | nta::SpriteBatch |
Namespaces | |
| nta | |
Macros | |
| #define | NTA_DEFAULT_DEPTH 0.5 |
| #define NTA_DEFAULT_DEPTH 0.5 |
Definition at line 9 of file SpriteBatch.h.
Referenced by nta::DebugBatch::addPolygon().


{% load i18n %}
{% trans "The main text always represents our current understanding of the situation. When something happens, we try to update it daily." %}
{% trans "To make this process transparent, you can browse through all previous versions here." %}
{% trans "If you want to link to the current version, or embed this story in your website, look here." %}
{% trans "Here you can see what changed between a previous version and now." %}
{% trans "The 'Current Events' section is a collection of links relevant to the topic" %}
{% trans "Sometimes we interview people or publish background research. You can find these here." %}