Rise of the bots: Team completes first census of Wikipedia bots
How Wikipedia's 1,601 bots help -- and hinder -- human users
| Source: | Stevens Institute of Technology |
| Summary: | Researchers have completed the first analysis of all 1,601 of Wikipedia's bots, using computer algorithms to classify them by function and shed light on the ways that machine intelligences and human users work together to improve and expand the world's largest digital encyclopedia. |
Since launching in 2001, Wikipedia has evolved into a sprawling repository of human knowledge, with 40 million collaboratively-written articles and almost 500 million monthly users. Maintaining that project requires more than 137,000 volunteer editors — and, increasingly, an army of automated, AI-powered software tools, known as bots, that continually scour the website to eliminate junk, add and tag pages, fix broken links, and coax human contributors to do better.
Researchers at Stevens Institute of Technology, in Hoboken, N.J., have now completed the first analysis of all 1,601 of Wikipedia's bots, using computer algorithms to classify them by function and shed light on the ways that machine intelligences and human users work together to improve and expand the world's largest digital encyclopedia. The work, published in Proceedings of the ACM on Human-Computer Interaction, could inform the development and use of bots in commercial applications ranging from online customer service to automated microchip design.
"AI is changing the way that we produce knowledge, and Wikipedia is the perfect place to study that," said Jeffrey Nickerson, a professor in the School of Business at Stevens and one of the study's authors. "In the future, we'll all be working alongside AI technologies, and this kind of research will help us shape and mold bots into more effective tools."
By leveraging Wikipedia's transparency and detailed record-keeping, Nickerson used automated classification algorithms to map every bot function as part of an interconnected network. By studying the places where functions clustered, the team identified bots' roles like "fixers," which repair broken content or erase vandalism; "connectors," which link pages and resources together; "protectors," which police bad behavior; and "advisors," which suggest new activities and provide helpful tips.
In total, bots play nine core roles on Wikipedia, accounting for about 10 percent of all activity on the site, and up to 88 percent of activity on some sub-sections such as the site's Wikidata platform. Most of that activity comes from more than 1,200 fixer-bots, which have collectively made more than 80 million edits to the site. Advisor-bots and protector-bots, by contrast, are less prolific, but play a vital role in shaping human editors' interactions with Wikipedia.
New members of online communities are more likely to stick around if they're welcomed by fellow members — but Nickerson and his team found that new Wikipedia users who interacted with advisor- and protector-bots were significantly more likely to become long-term contributors than those greeted by humans. That remained true even when the bots were contacting users to point out errors or delete their contributions, as long as the bots were cordial and clear about their reasons.
"People don't mind being criticized by bots, as long as they're polite about it," said Nickerson, whose team includes Feng Mai, graduate student Lei (Nico) Zheng and undergraduate students Christopher Albano and Neev Vora. "Wikipedia's transparency and feedback mechanisms help people to accept bots as legitimate members of the community."
Over time, some bots fell into obsolescence while others expanded and took on new roles. Studying the evolution of bots, and the ways that human-defined policies shape the bot ecosystem, remains a promising field for future research. "Are we heading for a world with a handful of multipurpose super-bots, or one with lots and lots of more specialized bots? We don't know yet," said Nickerson.
One thing is clear, though: Wikipedia's bots, and the governance and feedback systems that have sprung up around them, offer lessons for commercial bot-builders. "The things we're seeing on Wikipedia could be a harbinger of things to come in many different industries and professions," said Nickerson. "By studying Wikipedia, we can prepare for the future, and learn to build AI tools that improve both our productivity and the quality of our work."
make a difference: sponsored opportunity
Story Source:
Materials provided by Stevens Institute of Technology.
Note: Content may be edited for style and length.
Journal Reference:
- Lei (Nico) Zheng, Christopher M. Albano, Neev M. Vora, Feng Mai, Jeffrey V. Nickerson. The Roles Bots Play in Wikipedia. Proceedings of the ACM on Human-Computer Interaction, 2019; 3 (CSCW): 1 DOI: 10.1145/3359317
Cite This Page:
| MLA | Stevens Institute of Technology. "Rise of the bots: Team completes first census of Wikipedia bots: How Wikipedia's 1,601 bots help — and hinder — human users." ScienceDaily. ScienceDaily, 21 November 2019. <www.sciencedaily.com/releases/2019/11/191121121747.htm>. |
| APA | Stevens Institute of Technology. (2019, November 21). Rise of the bots: Team completes first census of Wikipedia bots: How Wikipedia's 1,601 bots help — and hinder — human users. ScienceDaily. Retrieved November 21, 2019 from www.sciencedaily.com/releases/2019/11/191121121747.htm |
| Chicago | Stevens Institute of Technology. "Rise of the bots: Team completes first census of Wikipedia bots: How Wikipedia's 1,601 bots help — and hinder — human users." ScienceDaily. www.sciencedaily.com/releases/2019/11/191121121747.htm (accessed November 21, 2019). |


Emmanuel Frecon -<EMAIL_ADDRESS>Swedish Institute of Computer Science Interactive Collaborative Environments Laboratory
The gestures library implements a low level Tcl service for gesture recognition. Mouse and keyboard events are pushed into the service, which will callback interested parties whenever a matching gesture has been recognised. The library does not draw on the screen, this is left to the caller.
The gestures library is a first attempt at a mouse gestures recognition library. I looked into using hooking in existing code, but found that implementing myself was more fun. The library is at inception. The current implementation does not recognise properly diagonals, which impairs a number of gestures. I have a number of ideas on how to extend it to support diagonals and will try to implement this in a near future.
Note that the gestures library depends on the uobj library, which is part of the current CVS version of the TIL (see http://til.sourceforge.net/).
For the time being, gestures has very little documentation and you will have to read the code. Read on though.
The library implements a low-level service. Mouse and keyboard gestures should be caught by the caller and forwarded to the library. Interested parties will define gestures using strings where characters have specific meaning: 'D' for down, 'U' for up, 'L' for left, 'R' for right, 's' for shift, 'c' for conrol and 'a' for alt. Whenever a gesture is recognised, the library will performed all registered callbacks for that gesture with some additional arguments.
The library uses contexts as its core object. There can be as many hermetically separated contexts as you wish. A new gesture context is created with ::gestures::new, which will return an identifier for the context. The command takes a number of key values parameters. The options recognised by the gestures are:
-subsample: The amount of motion subsampling pixels (see code).
All further operations are performed through such a context. ::gestures::config will reconfigure a context. ::gestures::add will register a new pair gesture string, command to the context, so that the command can be called whenever the gesture is recognised. Your code should push data into the library using ::gestures::push. Upon recognition, the callback will be appended the identifier of the context, the matching gesture definition string and the X and Y centre of the gesture.
gestures is subject to the new BSD license, I would appreciate to incorporate any modifications and improvements that you make to the library.
The library is hosted at the following address: http://www.sics.se/~emmanuel/?Code:gestures


A combinatoric approach
In an unxpected turn of events, returning from a trip to Yellowstone, I found in my phone the book “Principles and Techniques in Combinatorics”. Being a passionate about combinatorics I decided to give it a try. Only a few pages later, I was totally engaged with the material. I do plan to continue reading the following chapters in the upcoming months. However, at least for now, let me share some of the problems from the book that grabbed my attention and present as well the solutions I came up with.
Problem 1
Prove that it is impossible for seven distinct straight lines to be situated in the Euclidean plane so as to have at least six points where exactly three of these lines intersect and at least four points where exactly two of these lines intersect. (Putnam, 1973).
Problem 2
Let \(S=\{1, 2, \cdots, 1990\}\). A 31-element subset \(A\) of \(S\) is said to be good if the sum \(\sum_{a\in A} a\) is divisible by 5. Find the number of 31-element subsets of \(S\) which are good. (Proposed by the Indian team at the 31st IMO).
Problem 3
For \(\{1, 2, \cdots, n\}\) and each of its nonempty subsets, a unique alternating sum is defined as follows: Arrange the numbers in the subset in decreasing order and then, beginning with the largest, alternatively add and substract successive numbers. (For example, the alternating sum for \(\{1, 2, 4, 6, 9\}\) is \(9-6+4-2+1=6\) and for \(\{5\}\) is simply 5.) Find the sum of all such alternating sums for \(n=7\). (AIME, 1983/13)
Problem 4
For what \(n \in \mathbb{N}\) does there exist a permutation \((x_1, x_2, \cdots, x_n)\) of \((1, 2, \cdots, n)\) such that the differences \(|x_k-k|\), \(1\leq k \leq n\), are all distinct? (Proposed by M.J Pelling, 1989)
At this point, the curious reader can stop reading, and struggle with these problems. :)
Solutions
Here I present the casual solutions I came up with to solve the above tasks.
Problem 1
Let us consider the set of line pairs \(L = \{ (l_i, l_j) , \text{s.t. } 1 \leq i < j \leq 7 \}\), where \(l_i\) represents the line \(i\). The cardinality of this set is given by \(|L| = \binom{7}{2} = 21\). We can construct the set \(L\) based on the points of intersection for the given lines. Each point where exactly two lines intersect, adds one element to the set. Also, each point where exactly three lines intersect, adds \(\binom{3}{2} = 3\) elements to the set. Thus, the cardinality of the formed set is at least \(6 \times 3 + 4 \times 1 = 22\), which contradicts with the actual cardinality of the set and proves the claim.
Problem 2
Let us consider the circular arrangement of numbers of the set \(S\) in clock-wise increasing order. We notice that a 31-element subset \(A\) can be represented by a set of marked numbers in this circular arrangement. We define the bijection \(f\) as moving each marked number to its immediate right position in the circle. We notice that given a 31-element subset \(A\), if \(\sum_{a\in A} a \text{ mod } 5 = k\), then \(f(A) = \sum_{a\in A} (a+1) \text{ mod } 5 = (k + 1) \text{ mod } 5\). By denoting \(N_k\) the number of 31-element subsets with sum modulo 5 equal \(k\), we observe that by applying the bijection \(f\), we obtain \(N_0 = N_1 = N_2 = N_3 = N_4\). Finally, since \(\sum_{k=0}^4 N_k = \binom{1990}{31}\), the answer is given by \(N_0 = \frac15 \binom{1990}{31}\).
Problem 3
We define \(S_n\) to be the sum of alternating sums for all non-emtpy subsets of \(\{1, 2, \cdots, n\}\). We observe that we have two types of subsets. The ones where \(n\) is the maximum element and the ones where its not. There are \(2^{n-1}\) and \(2^{n-1} - 1\) such subsets for each case, respectively. The key insight is that for each subset of the second type, we can add the element \(n\) and obtain a unique subset of the first type. However, given the definition of alternating sums, when summing up both subsets from each type, all the terms will cancel except the \(n\). Thus, \(S_n = n 2^{n-1}\). The answer is given by \(7\times 2^6 = 448\).
Problem 4
From the problem statement it is evident that the expression \(|x_k-k|\) will take different values between \(0\) and \(n-1\). Moreover, given that \(\sum_{k=1}^n (x_k-k) = 0\), we can conclude that \(\sum_{k=1}^n |x_k-k| = \sum_{i=0}^{n-1} i = \frac{n(n-1)}{2}\) must an even number. We consider all possible values \(n\) of the form \(4p\), \(4p+1\), \(4p+2\) and \(4p+3\), for \(p \geq 0\). We can easily verify that for \(n=0,1 \ (\text{mod } 4)\) the previous expression is even. However for \(n=2,3\ (\text{mod } 4)\) we obtain odd numbers. Therefore, we can only obtain such permutations for \(n=0,1 \ (\text{mod } 4)\). To conclude the proof, we need to show how to construct such permutations for each case.
- When \(n=4p\) we can define our permutation by alternating numbers on opposite sides of the list \(\{1, 2, \cdots, n\}\) skipping the number \(3p\) (which maps to itself). For example, for \(p=1\), we have the following permutation \(1\rightarrow 4\), \(4\rightarrow 2\), \(2\rightarrow 4\) and \(3\rightarrow 3\).
- When \(n=4p+1\), we can define our permutation by alternating numbers on opposite sides of the list \(\{1, 2, \cdots, n\}\) skipping the number \(p+1\). For example, for \(p=1\) we have the following permutation \(1\rightarrow 5\), \(5\rightarrow 3\), \(3\rightarrow 4\), \(4\rightarrow 1\), and \(2\rightarrow 2\).
Every mathematical proof can be elegantly written within three lines. The difficult part is to find those lines. —Vladimir Spokoiny.


---
layout: post
title: 3/2
date: '2013-03-02T22:26:00.001-07:00'
author: Jacob .
tags:
modified_time: '2013-03-02T22:33:06.780-07:00'
blogger_id: tag:blogger.com,1999:blog-6400085873105072120.post-4706045659683801137
blogger_orig_url: http://www.svlark.com/2013/03/32.html
---
We had another realtor up today and found her much more to our liking. Pretty sure she's the one.
I managed to replace one faceplate.
Len has arrived so now we'll start getting things done for real.
Audrey did the first part of lesson 74.
238.


This is a wikipedia search and random page application. It is designed for freecodecamp wikipedia viewer challenge and fullfilled all user stories. Feedbacks are appreciated
@MiSeremet
Random Wiki


|
SoundFontInfoLib
2.21.6
Library for parsing and rendering SF2 files
|
Table value generators and initializers. More...
#include <DSPGenerator.hpp>
Public Member Functions | |
| template<typename T > | |
| void | generate (const std::string &name) |
| Generic table generator. More... | |
| void | generateTransform (std::function< double(int)> proc, const std::string &name, bool bipolar=false) |
| Generic ValueTransformer table initializer. More... | |
| void | generateCubic4thOrderWeights () |
| Generate the weights used for the cubic 4th-order interpolation calculations Based on code found in FluidSynth. More... | |
| Generator (std::ostream &os) | |
Public Attributes | |
| std::ostream & | os_ |
Table value generators and initializers.
This is only used by the DSPGenerators program which creates the DSP tables at compile time for quick loading at runtime.
| Generator::Generator | ( | std::ostream & | os | ) |
References generateCubic4thOrderWeights(), generateTransform(), and os_.
|
inline |
Generic table generator.
The template type T
must define a TableSize
class parameter that gives the size of the table to initialize, and it must define a Value
class method that takes an index value and returns a value to put into the table.
| name | the name of the table to initialize |
References os_.
|
inline |
Generate the weights used for the cubic 4th-order interpolation calculations Based on code found in FluidSynth.
Reordered and normalized to better understand coefficients.
Below is from FluidSynth source (see https://github.com/FluidSynth/fluidsynth/blob/master/src/gentables/gen_rvoice_dsp.c#L25):
Initialize the coefficients for the interpolation. The math comes from a mail, posted by Olli Niemitalo to the music-dsp mailing list (I found it in the music-dsp archives http://www.smartelectronix.com/musicdsp/).
References os_, and SF2::DSP::Tables::Cubic4thOrder::TableSize.
Referenced by Generator().
|
inline |
Generic ValueTransformer table initializer.
| proc | the function that generates a value for a given table index |
| name | the table name to initialize |
| bipolar | if true, initialize a bipolar table; otherwise, a unipolar one (default). |
References os_, SF2::MIDI::ValueTransformer::TableSize, and SF2::DSP::unipolarToBipolar().
Referenced by Generator().
| std::ostream& SF2::DSP::Tables::Generator::os_ |
Referenced by generate(), generateCubic4thOrderWeights(), generateTransform(), and Generator().


-*- html -*-
Wrangler overview page
@title Wrangler - an Erlang Refactoring Tool
@copyright 2006-2012 Huiqing Li, Simon Thompson
@author Huiqing Li
@author Simon Thompson
[http://www.cs.kent.ac.uk/projects/wrangler]
@doc Wrangler is an Erlang refactoring tool that supports interactive
refactoring of Erlang programs.
== Contents ==
- {@section Introduction}
- {@section The Interface of Wrangler}
- {@section Support for Macros}
- {@section Refactoring Code with Syntax Errors}
- {@section Download}
- {@section How to Use Wrangler}
- {@section References}
- {@section Acknowledgments}
== Introduction ==
Refactoring is the process of improving the design of a program without
changing its external behaviour. While refactoring by hand is possible, tool
support for refactoring is invaluable as it is more reliable, and allows
refactoring to be done (or undone) easily. Wrangler is such a tool that
supports interactive refactoring of Erlang programs. Wrangler currently
supports a number of basic Erlang refactorings, such as renaming of
variable/function/module names, generalisation of a function definition,
function extraction, folding against a function definition, duplicated code
detection, etc.
Wrangler also provides a set of process-based refactorings, including the
introduction of process naming, instead of providing access to a process
only through a dynamically-generated process id Wrangler also contains
a variety of refactorings which work with Erlang QuickCheck, introducing
and merging constructs such as ?LET
and ?FORALL
.
Transforming data types in Erlang can be difficult, as Erlang functions
can take values of any type, in principle. There are situations -- particularly
in implementing an Erlang behaviour , which can be thought of as an
interface for a set of callback functions -- where the types are more
constrained, and where data transformations are possible. In particular
we have implemented transformations for state data in various kinds
of generic state machine in both the OTP library and QuickCheck.
In implementing Wrangler we have chosen to respect various features of
the language and related tools. Wrangler is able to process modules which
use macros, including the Erlang test frameworks that are in
regular use. Wrangler also respects the naming conventions in those
test frameworks.
Wrangler provides a portfolio of decision support tools. The code inspector
highlights local code smells and a number of reports highlight issues in
the module structure of projects, including circular inclusions and other
potential faults. The code clone detection facilities can be
used on large multi-module projects to report on code clones and how they
can be removed; clone detection can be preformed incrementally on larger code
bases, for example as part of a continuous integration approach to software
construction.
Wrangler has recently been extended with a framework that allows users to define
for themselves refactorings and code inspection functions that suit their
needs. These are defined using a template- and rule-based
program transformation and analysis API. Wrangler also supports a
domain-specific language that allows users to script composite refactorings,
test them and apply them on the fly.
User-defined refactorings and scripts are not second-class citizens: like
the existing Wrangler refactorings, user-defined refactorings benefit
from features such as results preview, layout preservation, selective
refactoring, undo and so on.
Built on top of the functionalities provided by the Erlang syntax-tools
package, Wrangler is embedded in the Emacs/Xemacs editing environment, and
makes use of the functionalities provided by Distel, an Emacs-based user
interface toolkit for Erlang, to manage the communication between the
refactoring tool and Emacs. Wrangler is also integrated within
Eclipse, as a part of the ErlIDE plugin for Erlang.
== The Interface of Wrangler ==
=== Wrangler in Emacs ===
Below is a snapshot of Wrangler embedded in Emacs, which shows a particular
refactoring scenario. The user has selected the expression
io:format("Hello")
in the definition of repeat/1
, has
chosen the Generalise Function Definition command from the
Refactor sub-menu, and has just entered a new parameter name A in the
mini-buffer.
The result of this refactoring is shown in the snapshot below.
Preview of the changes to be made by a refactoring is supported, and the
user could choose to commit or abort the refactoring result after preview.
Wrangler's preview uses the Ediff package for Emacs.
All the implemented refactorings are module-aware. In the case that a
refactoring affects more than one module in the program, a message telling
which files have been modified by the refactorer will be given after the
refactoring has been successfully done. The Customize Wrangler
command from the Refactor sub-menu allows the user to specify the
boundary of the program, i.e., the directories that will be searched and
analysed by the refactorer, as shown in the example snapshot below.
Undo is supported by the refactorer. Applying undo once will revert
the program back to the status right before the last refactoring performed.
However, PLEASE NOTE that the refactorer undo is currently separate
from the Emacs undo, and undoing a refactoring will lose all the editing
activities after the refactoring.
=== Wrangler in Eclipse ===
Below is a snapshot of Wrangler embedded in Eclipse + Erlide.
== Support for Macros ==
Wrangler makes use of functionalities provided by the `epp_dodger' module
from the Erlang `syntax_tools' library to parse Erlang source code, and
should be able to refactor Erlang modules containing preprocessor directives
and macro applications, as long as the macro definitions are syntactically
"well-behaved".
== Refactoring Code with Syntax Errors ==
Wrangler accepts Erlang programs with syntax errors or macro definitions
that cannot be parsed by `epp_dodger'. In the case that the program under
consideration has syntax errors or unparsable macros, functions/attributes
to which these syntax errors belong are not affected by the refactoring
process; however, warning messages asking for manual inspection of those
parts of the program are given after the refactoring.
== Download ==
Wrangler is downloadable from Github: [https://github.com/RefactoringTools], and also
from [http://www.cs.kent.ac.uk/projects/wrangler]
== How to Use Wrangler ==
- Open an Erlang source file in the Emacs editor. You should now have a
menu called Erlang, if you have configured Emacs properly to
use the Erlang-mode (see the file INSTALL otherwise).
- To start Wrangler, type: `M-x erlang-wrangler-on', or
alternatively `Ctrl-c Ctrl-r'. After that, new menu Wrangler should appear in the
menu bar (see INSTALL otherwise).
- To stop Wrangler, type `M-x erlang-wrangler-off', or
alternatively use `Ctrl-c Ctrl-r' again. The Refactor and Inspector
menus will disappear from the menu bar.
- You can use `Ctrl-c Ctrl-r' to toggle Wrangler on or off.
- For most refactorings, the editor interface will pass the current
filename (should be the module name, as well), the refactoring command,
and the current cursor position. For some refactorings, you'll also
need to highlight an expression, or enter a new name.
- The Customize Wrangler menu in the Wrangler submenu allows you
to specify the boundary of the system by giving the list of directories
to search for Erlang source files/header files that could be affected
by a refactoring.
- For most refactorings, the editor interface will pass the current filename
(should be the module name, as well), the refactoring command, and the current
cursor position. For some refactorings, you'll also need to highlight an
expression, or enter a new name.
How to use:
Extensions:
== References ==
Our Refactoring
Functional Programs project website contains more information and
references about refactoring functional, especially Haskell, programs; and
our progress and ideas about refactoring Erlang programs are available at
our Wrangler project
webpage. Here are some publications related to Wrangler:
-
A
Domain-Specific Language for Scripting Refactorings in
Erlang.
Huiqing Li and Simon Thompson. FASE 2012, Tallinn, Estonia.
-
A
User-extensible Refactoring Tool for Erlang Programs.
Huiqing Li and Simon Thompson.
Technical Report 4-11, University of Kent, October 2011.
-
Extracting
Properties from Test Cases by Refactoring.
Huiqing Li, Simon Thompson, and Thomas Arts.
In Steve Counsell, editor, Proceedings of the Refactoring and Testing
Workshop (RefTest 2011), page 2. IEEE digital library, March 2011.
-
Incremental Code Clone Detection and Elimination for Erlang Programs.
Huiqing Li and Simon Thompson.
In Dimitra Giannakopoulou and Fernando Orejas, editors, Proceedings of
the Conference on Fundamental Approaches to Software Engineering
(FASE'11), Lecture Notes in Computer Science. Springer, March 2011.
-
Improved
Testing Through Refactoring: Experience from the ProTest project.
Huiqing Li and Simon Thompson.
In Leonardo Bottaci and Gordon Fraser, editors, Testing - Practice and
Research Techniques: 5th International Academic and Industrial Conference,
TAIC PART 2010, volume 6303 of Lecture Notes in Computer
Science, pages 198-202. Springer, September 2010.
-
Refactoring Support for Modularity Maintenance in Erlang.
Huiqing Li and Simon Thompson.
In Jurgen Vunju and Cristina Marinescu, editors, Tenth IEEE International
Working Conference on Source Code Analysis and Manipulation, pages
157-166. IEEE Computer Society, September 2010.
-
An
Expression Processor: A Case Study in Refactoring Haskell Programs.
Christopher Brown, Huiqing Li, and Simon Thompson.
In Rex Page, editor, Eleventh Symposium on Trends in Functional
Programming, page 15pp, May 2010.
-
Similar
Code Detection and Elimination for Erlang Programs.
Huiqing Li and Simon Thompson.
In Manuel Carro and Ricardo Pena, editors, Practical Aspects of
Declarative languages 2010, number 5937 in Lecture Notes in Computer
Science, pages 104-118. Springer, January 2010.
-
Testing-framework-aware Refactoring.
Huiqing Li and Simon Thompson.
In The Third ACM Workshop on Refactoring Tools, pages 1-4, Orlando,
Florida, October 2009.
-
Clone
Detection and Removal for Erlang/OTP within a Refactoring
Environment.
Huiqing Li and Simon Thompson.
In Massimiliano Di Penta and Jens Knodel, editors, Third International
Workshop on Detection of Software Clones, page 1pp, Kaiserslautern,
Germany, March 2009.
-
Clone
Detection and Removal for Erlang/OTP within a Refactoring
Environment.
Huiqing Li and Simon Thompson.
In ACM SIGPLAN Workshop on Partial Evaluation and Program Manipulation
(PEPM'09), Savannah, Georgia, USA, January 2009.
-
Tool
Support for Refactoring Functional Programs.
Huiqing Li and Simon Thompson.
In Danny Dig, Robert Fuhrer, and Ralph Johnson, editors, Proceedings of
the Second ACM SIGPLAN Workshop on Refactoring Tools, page 4pp,
Nashville, Tennessee, USA, October 2008.
-
Refactoring with Wrangler, updated: Data and process refactorings, and integration with
Eclipse.
Huiqing Li, Simon Thompson, George Orosz, and Melinda Toth.
In Zoltan Horvath and Tee Teoh, editors, Proceedings of the Seventh ACM
SIGPLAN Erlang Workshop, page 12pp. ACM Press, September 2008.
-
Refactoring with Wrangler, updated.
Huiqing Li, Simon Thompson, György Orosz, and Melinda Töth.
In ACM SIGPLAN Erlang Workshop 2008, Victoria, British Columbia,
Canada, September 2008.
-
Clone
Detection and Removal for Erlang/OTP within a Refactoring
Environment.
Huiqing Li and Simon Thompson.
In P. Achten, P. Koopman, and M. T. Morazán, editors, Draft Proceedings of
the Ninth Symposium on Trends in Functional Programming(TFP), The
Netherlands, May 2008.
-
Tool
Support for Refactoring Functional Programs.
Huiqing Li and Simon Thompson.
In Partial Evaluation and Program Manipulation, San Francisco,
California, USA, January 2008.
-
Testing
Erlang Refactorings with QuickCheck.
Huiqing Li and Simon Thompson.
In Draft Proceedings of the 19th International Symposium on
Implementation and Application of Functional Languages, IFL 2007,
Freiburg, Germany, September 2007.
-
Testing
Erlang Refactorings with QuickCheck.
Huiqing Li and Simon Thompson.
In the 19th International Symposium on Implementation and Application of
Functional Languages, IFL 2007, LNCS, Freiburg, Germany, September 2007.
-
Refactoring
Erlang Programs.
Huiqing Li, Simon Thompson, László Lövei, Zoltán Horváth, Tamás Kozsik, Anikó
Víg, and Tamás Nagy.
In The Proceedings of 12th International Erlang/OTP User Conference,
Stockholm, Sweden, November 2006.
-
A
Comparative Study of Refactoring Haskell and Erlang Programs.
Huiqing Li and Simon Thompson.
In Massimiliano Di Penta and Leon Moonen, editors, Sixth IEEE
International Workshop on Source Code Analysis and Manipulation (SCAM
2006), pages 197-206. IEEE, September 2006.
== Acknowledgments ==
The work was initially supported by EPSRC in the UK, and is now by the
European Commission. We are very grateful that we were able to build the
tool on top of Distel
and
Erlang
SyntaxTools, and make use some of the ideas from
Dialyzer.


The Rwinsteps package facilitates communication between R and the Rasch modeling software Winsteps. The package currently includes functions for reading and writing command files, sending them to Winsteps, reading and writing data according to command file specifications, reading output into R, and plotting various results.
| Version: | 1.0-1 |
| Depends: | R (≥ 2.12.0) |
| Published: | 2012-01-30 |
| Author: | Anthony Albano, Ben Babcock |
| Maintainer: | Anthony Albano <tony.d.albano at gmail.com> |
| License: | GPL-2 | GPL-3 [expanded from: GPL (≥ 2)] (see file LICENSE) |
| URL: | http://www.r-project.org |
| NeedsCompilation: | no |
| Materials: | NEWS |
| CRAN checks: | Rwinsteps results |
| Reference manual: | Rwinsteps.pdf |
| Package source: | Rwinsteps_1.0-1.tar.gz |
| Windows binaries: | r-devel: Rwinsteps_1.0-1.zip, r-release: Rwinsteps_1.0-1.zip, r-oldrel: Rwinsteps_1.0-1.zip |
| OS X binaries: | r-release: Rwinsteps_1.0-1.tgz, r-oldrel: Rwinsteps_1.0-1.tgz |
| Old sources: | Rwinsteps archive |
Please use the canonical form https://CRAN.R-project.org/package=Rwinsteps to link to this page.


Foundational framework for everything frontend at taenzer digital.
The Base Unit
The spacing system is based on the $unit
value. Its length is half of the line height (or the text line height is defined as two units).
Vertical distances are a multiple of the unit value.
Horizontal distances are less rigid since variable display sizes require more flexibility and they have a lesser influence on the perception of rythm. But where applicable, they are also a multiple of the unit value.
This value is dependent on the screen size and the variables $text-size-lower-bound-px
, $text-size-upper-bound-px
, $rem-grow-start-px
and $rem-grow-end-px
. Note: These values are in css px, but have to be stated unitless for technical reasons.
Fonts
Fonts can be set with the $text-font
and the $head-font
variables. Per default, both are set to the system font. If you only set $text-font
, $head-font
is set to the same value.
The leading of the text can be set with the $text-leading
variable (1.5 default). It determinates the ratio of font size and line height. The same can be done for the headline font with $head-leading
if the two different fonts needs optical finetuning. Its recommended to stay near the default.
Font Sizes
Font sizes are driven by the modular scale. The scale can be customized by setting the variables $type-ratio and $type-base (without unit). Furthermore there is $cascade-limit (default 12) to set the limit of the cascade. The variable $head-nodes is a list defining the sizes of the default headlines in the modular scale beginning with h1.
The headline utility classes are head-
following the position in the cascade.
There are two text sizes that can be selected with the utility classes .text
and text-s
. These classes set the size and the font itself. Since .text
is the default for nearly all elements and footnote sized text is not meant to be used often, these classes should not come that much.
Further examples:
.text-s
.text
.head-1
.head-2
.head-3
.head-4
.head-5
.head-6
.head-7
.head-8
.head-9
.head-10
.head-11
.head-12
Margins and Paddings
Margins and and paddings are set with the utility class
.[m/p][side]=size
.
For example, to set the right padding to 3 units, we use the class pr=3
and to set the bottom margin to -1 unit, mb=-1
.
Side can be left out completly to set all sides at once or it can be set to x
or y
to set the left and right side or the top and bottom sides respectively to the same value.
Further examples:

...
margin top is set to 1 unit

...
left and right padding is set to 2 units

...
all margins are 5 units

...
bottom and top padding is set to 3 units
Try it out yourself:
Layout and flex utilities
CSS flexbox is more or less exposed as is. In combination with a few other utilities classes these are strong bulding blocks for layouting. Here is a list with all the utilites with the associated css rules.
 This takes care of gutter widths, breaks and such. The gutter width is set to one unit, but can be overriden with the $grid-gap
variable.
Offsets are available with the left and right modifier and for all the widths fractions.
All these classes are prefixed for the different size classes, see responsive design.
Further examples:
.w=site
max-width: 37.5rem;
margin-left: auto;
margin-right: auto;
.w=viewport
width: 100vw;
margin-left: 50%;
transform: translateX(-50%);
.w=full
width: 100%;
.h=full
min-height: 100%;
.h=viewport
min-height: 100vh;
.w=1/2
width: 50%;
.w=1/3
width: 33.33333%;
.w=1/4
width: 25%;
.w=1/6
width: 16.66667%;
.w=1/8
width: 12.5%;
.w=1/12
width: 8.33333%;
.w=2/3
width: 66.66667%;
.w=3/4
width: 75%;
.w=5/6
width: 83.33333%;
.w=11/12
width: 91.66667%;
Try it out yourself:
Borders
The style of the border can be controlled with the $border-radius
and $border-width
variables.
Further examples:

...
borders on all sides

...
left and right borders

...
top and bottom borders

...
top border

...
bottom border

...
left border

...
right border
Radius
Big radii to create circles or pill like shapes can be created with `r-circle`. Of course, die modified classes `rl-circle`, `rr-circle`, `rt-circle` and `rb-circle` to restrict the radius to the left, right, top or bottom are also avaiable.
Corners can be rounded with the following classes
Further examples:

...
rounded on all sides

...
rounded on the left side

...
rounded on the right side

...
rounded on the top side

...
rounded on the bottom side
Try it out yourself:
Arrows
Elements can be decorated with arrows on the right side like so:
Try it out yourself:
Tables
To apply the bedrock table styling, just wrap the table in a figure with the class table
.
Try it out yourself:
Advanced
If the display is to small for the table, it's set to scroll. td
s with numeric data (and the th
of the column) should get the class numeric
. This enables tabular numbers and appropriate alignment.
Its consired good style to align numbers on the decimal point. Since there is no build in solution for that in the css spec, bedrock provides a few helper classes. To use them, the positions after the dot have be wrapped in a span with the class dec-pos-align
or dec-pos-align-wide
.
Try it out yourself:
Placeholder
This is just a small utility that fills up html elements with word-like shapes. This enables quick tests how different content flows. Also, it is more distinct from actual content than the typical lorum ipsum placeholders and less likely to be overlooked in the final product.
Further examples:

Interactive Elements
Accordion
The Accordion element is based on the html details element. Multiple details must be wrapped in a container with class accordion
.
Further examples:
Click here b
Responsive Design
Bedrocks tools for responsive design are build upon the mobile first principle. Per default, there are four device classes, sm(phones), md(tablets, phones in landscape), lg(laptop, small desktops), xl(normal desktop, external screens).
Mobile first means that we start with the mobile styling and add more rules as the screen size grows. To do that there are modified versions of a lot of utility classes (mostly everything that has to do with layout and size).
For example, a element with the classes mt=1 lg:mt=2 xl:mt=3
has one unit margin on all phones and tablets, margin two on screens classed as lg and margin three on screens classed xl.
In general, everything that has to do with layout and spacing is prefixed.
Forms
Try it out yourself:
Select
One important note for selects: The class arrow-down
has to be set explictly. In return, this decorator class can be used everywhere (for example in drop down buttons) and is compatible with all colors schemes, contextual variations and animations.
Try it out yourself:
Check- and Radiobuttons
Checkboxes and radiobuttons must be wrapped in a label and must contain an empty sibling element for technical reasons.
Its important to not use a radio input with the toggle styling, since the behaviour would be surprising for the user.
Addional styling can be added to the embedded span
Try it out yourself:
Contextual variations
To create contextual variations, the color utility classes and the elevated
class can be prefixed with hover:
or focus:
Try it out yourself:
Aspect Ratio
To apply aspect ratio to an element. The element must be wrapped in a container with the class ar=1/1 ar=16/9 ar=4/3
Also a mixin called ar($width, $height)
is available to create custom ratios.
Try it out yourself:
Visibility
To hide or show an element, the visibility utility classes visible
and hidden
can be used. They can also be prefixed with the responsive prefixes
Try it out yourself:
Icons
We make use of inline SVGs for icons. Every SVG iconset can be integrated.
Icon Sizes
We defined Utility Classes for icon sizes analog to the headline sizes. .icon, .icon-l, .icon-xl, .icon-2xl, .icon-3xl, .icon-4xl
. Those classes can be prefixed with our responsive prefixes
Background images
If you want to use a big background image, for example for a hero banner, you can use the bg-img
class. You can set the image url with the data-url
attribute.
The image is loaded after the page itself and will ease in. The idea is that non functional parts of the - site like a hero image - shouldn't impact the inital page load. So make sure that the background color of that element is set so that the page looks good even if the image never loads, which might happen to users on very bad connections.
Try it out yourself:
Focal Point
Per default, the image is centered. If there is a focal point in the image that is not the center, it can be specified with the data-focal
attribute like so:
Try it out yourself:
Tabs
Try it out yourself:
print.css
When you put in your html header, you get a print friendly restyling. Headers and footers are automaticly hidden, the page width class is a full site and all colors are set to black and white (can be modifed with the
$print-color
variable). The page margins are set with the $print-margin
variable.
All layout and aspect ratio classes get an addional prefix print:
to add print specific styling and you can hide and show elements with the print-only
and screen-only
utility classes.
Also, external links will show their target in parenthesis after the link text.


| Package | Description |
|---|---|
| eu.h2020.helios_social.modules.socialgraphmining.GNN |
| Modifier and Type | Method and Description |
|---|---|
GNNMiner |
CentralizedGNNMiner.getBaseMiner() |
GNNMiner |
GNNMiner.setDeniability(double plausibleDeniability,
double differentialPrivacy)
Enables plausible deniability and differential privacy handling by permuting the ego and its alter's parameters
with a random noise proportional to a given constant and their norm.
|
GNNMiner |
GNNMiner.setEdgePointsLearningMultiplier(double incomming,
double outgoing) |
GNNMiner |
GNNMiner.setEmbeddingExchangeProtocol(EmbeddingExchangeProtocol embeddingExchangeProtocol) |
GNNMiner |
GNNMiner.setLearningRate(double learningRate)
The learning rate (default is 1) from which GNNMiner training starts.
|
GNNMiner |
GNNMiner.setLearningRateDegradation(double learningRateDegradation)
Performs a fixed degradation of the learning rate over training epochs by multiplying the latter
with a given factor (default is 0.95) after each epoch.
|
GNNMiner |
GNNMiner.setMaxTrainingEpoch(int maxEpoch)
Limits the number of training epochs (default is 1000) over which to
train the GNNMiner.
|
GNNMiner |
GNNMiner.setMinTrainingRelativeLoss(double convergenceRelativeLoss)
When the GNNMiner is being trained, training stops at epochs where
abs(previous epoch loss - this epoch loss) < convergenceRelativeLoss*(this epoch loss)
where losses are weighted cross entropy ones.
|
GNNMiner |
GNNMiner.setRegularizationAbsorbsion(double regularizationAbsorbsion)
Multiplies regularization tensors with this value before setting them as regularization;
value of 1 (default) produces regularization of calculated alter embeddings towards the
embeddings calculated on alter devices.
|
GNNMiner |
GNNMiner.setRegularizationWeight(double regularizationWeight)
The regularization weight (default 0.1) to apply during training of the GNNMiner.
|
GNNMiner |
GNNMiner.setSpectralAlignment(boolean enableSpectralAlignment)
Faster convergence to more robust embeddings of evolving user preferences by trying to align
the dimensions of received embeddings towards with their locally understood spectral representation (default
is false).
|
GNNMiner |
GNNMiner.setTrainingExampleDegradation(double trainingExampleDegradation)
Degrades example weights each time a new one is generated through
SocialGraphMiner.newInteraction(eu.h2020.helios_social.core.contextualegonetwork.Interaction, java.lang.String, eu.h2020.helios_social.modules.socialgraphmining.SocialGraphMiner.InteractionType) by calling
ContextTrainingExampleData.degrade(double, double) to multiply previous weights with the given degradation factor
(default is 0.5). |
GNNMiner |
GNNMiner.setTrainingExamplePropagation(boolean enableTrainingExamplePropagation)
Sets whether to propagate training examples to communicating devices (this behavior is de-activeated by default).
|
GNNMiner |
GNNMiner.setTrainingExampleRemovalThreshold(double trainingExampleRemovalThreshold)
Sets the threshold weight at which old training examples are removed (default is 0.1).
|


The aim of this puzzle is to find a bomb, hidden on one cell of a grid. Each turn, you get to move wherever you want on the grid, and you get the direction of the bomb based on your position (up, down, left, up-right, etc). As explained in the code, a solution is to run a binary search. In other words, you move so that each indication allows you to narrow down (by half, or more) the number of possible locations where the bomb could be.
#include <stdlib.h> #include <stdio.h> int main(int argc, char** argv) { int W, H, turns, x, y; scanf("%d %d\n%d\n%d %d\n", &W, &H, &turns, &x, &y); // these 4 variables circumscribe a zone where the bomb is int xInf = 0; int xSup = W-1; int yInf = 0; int ySup = H-1; /* each turn, we go to the center of this zone, and the direction provided allows us to narrow down the zone . It is like a 2 dimensional binary search.*/ char BD[2] = { ' ', ' ' }; while (1) { scanf("%s", BD); if (BD[0] == 'U') ySup = y-1; else if (BD[0] == 'D') yInf = y+1; else ySup = yInf = y; if (BD[0] == 'R' || BD[1] == 'R') xInf = x+1; else if((BD[0] == 'L') || (BD[1] == 'L')) xSup = x-1; else xSup = xInf = x; x = (xInf + xSup)/2; y = (yInf + ySup)/2; printf("%d %d\n", x, y); } return EXIT_SUCCESS; }


Almighty Enumerable
Date: Jan 17, 2015
Pair Programming and Fear Feedback
When I think of the term 'group work' or 'group challenge', the words I associate with are 'unsatisfying', 'inefficient' and 'avoid if you can'. Although I like to get help and advice from smarter people and learn from them, I like to do things on my own way. Why? Because I do not like to be vulunerable. I don't like people think that I am being slow. It's not that I have no ability to do it but I just do not like the feel that people watching me and see how fast I figure things out.
People says life is a journey of knowing oneself
It is fairly new discovery that I don't like to be vulunerable. I always thought that I am confident person and like to lead conversation. When I do pair programming, I always set the time and then if it goes to more than hour, I suggest to do 'own research' and come back together some other time instead of trying to figure things out together. In this way, I can do as much research I need to come up with an answer and being smart.
 It has been wonderful opportunites to learn about different thinking and problem solving style. Observing others figure out how to solve problems are surely fun and rewarding experience.
What frustrates me about pair programing session is really my coding skill. I wish I can help others and lead the session. Yet, often I found myself become just a code typer than a pair partner.
What's wrong with Feedbacks?
As much as I am not a confident pair partner, I am not looking forward reading feedbacks. It's not that I am expecting bad feedbacks but getting feedback and learn from it isn't something that I am used to. I think it's also because of my incompetence in programming skill.
So far the feedbacks that I received are all positive. Feedbacks aren't very specific but in general they are encouraging and suppotive. Although I avoid as much as I can to read feedbacks, I am appreciating people done work with me and provided feedback. Digesting and improving myself after reading feedbacks are my tasks and I need to be used to. At leaset I know where I need to improve, I think I do have a hope.
Providing a feedback is as big challenge as much as digesting provided feedback. Professionally, I haven't had a chance to provide feedbacks to others so this is fairly new challenge for me. The hardest thing about providing feedbacks is being honest. Give negative feedback is still very challenging to me although I know that it is necessary. I also think that this is due to my confidence issue.
Because I do not like dealing with feedbacks, I don't see the usefulness of feedbacks. To make the best of the program, I should work on my fears and issues to accept others opinions and use as fuel for going forward. I also need to provide honest feedbacks to others because that's what I supposed to do and it will help them. Perhaps the all issue regarding feedback systems comes from my effort level and incompetency in general.
Pair Programming and Fear Feedback
When I think of the term 'group work' or 'group challenge', the words I associate with are 'unsatisfying', 'inefficient' and 'avoid if you can'. Although I like to get help and advice from smarter people and learn from them, I like to do things on my own way. Why? Because I do not like to be vulunerable. I don't like people think that I am being slow. It's not that I have no ability to do it but I just do not like the feel that people watching me and see how fast I figure things out.
People says life is a journey of knowing oneself
It is fairly new discovery that I don't like to be vulunerable. I always thought that I am confident person and like to lead conversation. When I do pair programming, I always set the time and then if it goes to more than hour, I suggest to do 'own research' and come back together some other time instead of trying to figure things out together. In this way, I can do as much research I need to come up with an answer and being smart.
 It has been wonderful opportunites to learn about different thinking and problem solving style. Observing others figure out how to solve problems are surely fun and rewarding experience.
What frustrates me about pair programing session is really my coding skill. I wish I can help others and lead the session. Yet, often I found myself become just a code typer than a pair partner.
What's wrong with Feedbacks?
As much as I am not a confident pair partner, I am not looking forward reading feedbacks. It's not that I am expecting bad feedbacks but getting feedback and learn from it isn't something that I am used to. I think it's also because of my incompetence in programming skill.
So far the feedbacks that I received are all positive. Feedbacks aren't very specific but in general they are encouraging and suppotive. Although I avoid as much as I can to read feedbacks, I am appreciating people done work with me and provided feedback. Digesting and improving myself after reading feedbacks are my tasks and I need to be used to. At leaset I know where I need to improve, I think I do have a hope.
Providing a feedback is as big challenge as much as digesting provided feedback. Professionally, I haven't had a chance to provide feedbacks to others so this is fairly new challenge for me. The hardest thing about providing feedbacks is being honest. Give negative feedback is still very challenging to me although I know that it is necessary. I also think that this is due to my confidence issue.
Because I do not like dealing with feedbacks, I don't see the usefulness of feedbacks. To make the best of the program, I should work on my fears and issues to accept others opinions and use as fuel for going forward. I also need to provide honest feedbacks to others because that's what I supposed to do and it will help them. Perhaps the all issue regarding feedback systems comes from my effort level and incompetency in general.


Publications
|
|
K. E. Alley, C. T. Wild, A. Luckman,
T. A. Scambos, M. Truffer, E. C. Pettit,
A. Muto, B. Wallin, M. Klinger, T. Sutterley,
S. F. Child, C. Hulen, J. T. M. Lenaerts,
M. Maclennan, E. Keenan, and D. Dunmire,
Two decades of dynamic change and progressive destabilization
on the Thwaites Eastern Ice Shelf, The Cryosphere,
15(11):5187–5203, 2021.
[ bib |
http ]
|
|
|
Y. Mohajerani, D. Shean, A. Arendt and
T. C. Sutterley.
Automated Dynamic Mascon Generation for GRACE and GRACE-FO Harmonic
Processing, Remote Sensing, 13(3134), 2021.
[ bib |
http ]
|
|
|
K. M. Brunt, B. E. Smith, T. C. Sutterley,
K. T. Kurtz and T. A. Neumann.
Comparisons of Satellite and Airborne Altimetry with Ground-Based Data
from the Interior of the Antarctic Ice Sheet, Geophysical Research
Letters, 48(2), 2021.
[ bib |
http ]
|
|
|
R. L. Hawley, T. A. Neumann, M. C. Stevens,
K. M. Brunt and T. C. Sutterley.
Greenland Ice Sheet Elevation Change: Direct Observation of Process and
Attribution at Summit, Geophysical Research Letters, 47(22), 2020.
[ bib |
http ]
|
|
|
I. Velicogna, Y. Mohajerani, G. A, F. Landerer,
J. Mouginot, B. Noël, E. Rignot,
T. C. Sutterley, M. van den Broeke,
J. M. van Wessem and D. Wiese.
Continuity of ice sheet mass loss in Greenland and Antarctica from the
GRACE and GRACE Follow-On missions, Geophysical Research
Letters, 47(8), 2020.
[ abstract |
bib |
http ]
|
|
|
T. C. Sutterley, I. Velicogna and C.-W. Hsu.
Self-Consistent Ice Mass Balance and Regional Sea Level from
Time-Variable Gravity, Earth and Space Science, 7(3), 2020.
[ abstract |
bib |
http |
data ]
|
|
|
The IMBIE team. Mass balance of the Greenland Ice Sheet from 1992 to 2018.
Nature, 2019.
[ abstract |
bib |
http ]
|
|
|
T. C. Sutterley and I. Velicogna.
Improved estimates of geocenter variability from time-variable gravity
and ocean model outputs, Remote Sensing, 11(18): 2108, 2019.
[ abstract |
bib |
http |
data ]
|
|
|
T. C. Sutterley, T. Markus, T. Neumann,
M. van den Broeke, J. M. van Wessem and
S. Ligtenberg.
Antarctic Ice Shelf Thickness Change from Multimission Lidar Mapping.
The Cryosphere, 13, 1801–1817, 2019.
[ abstract |
bib |
http |
data ]
|
|
|
E. Ciracì, I. Velicogna and T. C. Sutterley.
Mass Balance of Novaya Zemlya Archipelago, Russian High Arctic, Using
Time-Variable Gravity from GRACE and Altimetry Data from ICESat and
CryoSat-2. Remote Sensing, 10(11): 1817, 2018.
[ abstract |
bib |
http ]
|
|
|
T. C. Sutterley, I. Velicogna, X. Fettweis,
E. Rignot, B. Noël and M. van den Broeke.
Evaluation of reconstructions of snow/ice melt in Greenland by regional
atmospheric climate models using laser altimetry data.
Geophysical Research Letters, 45(16):8324–8333, 2018.
[ abstract |
bib |
http |
data ]
|
|
|
P. Kishore, I. Velicogna, T. C. Sutterley,
Y. Mohajerani, E. Ciracì and G. N. Madhavi.
A case study of mesospheric planetary waves observed over a
three-radar.
Annales Geophysicae, 36(3):925–936, 2018.
[
http ]
|
|
|
The IMBIE team. Mass balance of the Antarctic Ice Sheet from 1992 to 2017.
Nature, 558(7709):219–222, 2018.
[ abstract |
bib |
http ]
|
|
|
P. Kishore, J. Jayalakshmi, P.-L. Lin, I. Velicogna,
T. C. Sutterley, E. Ciracì, Y. Mohajerani
and S. Kumar.
Investigation of Kelvin wave periods during Hai-Tang typhoon using
Empirical Mode Decomposition.
Journal of Atmospheric and Solar-Terrestrial Physics,
164:192–202, 2017.
[ http ]
|
|
|
A. Khazendar, E. J. Rignot, D. M. Schroeder,
H. Seroussi, M. P. Schodlok, B. Scheuchl,
J. Mouginot, T. C. Sutterley and I. Velicogna.
Rapid submarine ice melting in the grounding zones of ice shelves in
West Antarctica.
Nature Communications, 7(13243), 2016.
[ abstract |
bib |
http ]
|
|
|
G. Basha, P. Kishore, M. Venkat Ratnam,
M. J. Ouarda, I. Velicogna and T. Sutterley.
Vertical and latitudinal variation of the intertropical convergence
zone derived using GPS radio occultation measurements.
Remote Sensing of Environment, 163:262–269, 2015.
[ http ]
|
|
|
P. Kishore, I. Velicogna, M. Ratnam, G. Basha,
M. J. Ouarda, S. P. Namboothiri,
J. H. Jiang, T. C. Sutterley,
G. N. Madhavi and S. V. Rao.
Sudden stratospheric warmings observed in the last decade by
satellite measurements.
Remote Sensing of Environment, 184:263–275, 2016.
[ http ]
|
|
|
P. Kishore, S. Jyothi, G. Basha,
S. V. B. Rao, M. Rajeevan,
I. Velicogna and T. C. Sutterley.
Precipitation climatology over India: validation with observations
and reanalysis datasets and spatial trends.
Climate Dynamics, 46(1-2):541–556, 2016.
[ http ]
|
|
|
T. C. Sutterley, I. Velicogna, E. Rignot, J. Mouginot,
T. Flament, M. R. van den Broeke,
J. M. van Wessem and C. H. Reijmer.
Mass loss of the Amundsen Sea Embayment of West Antarctica from four
independent techniques.
Geophysical Research Letters, 41(23):8421–8428, 2014.
[ abstract |
bib |
http ]
|
|
|
I. Velicogna, T. C Sutterley and
M. R. van den Broeke.
Regional acceleration in ice mass loss from Greenland and Antarctica
using GRACE time-variable gravity data.
Geophysical Research Letters, 41(22):8130–8137, 2014.
[ abstract |
bib |
http ]
|
|
|
T. C. Sutterley, I. Velicogna, B. Csatho,
M. R. van den Broeke, S. Rezvanbehbahani
and G. Babonis.
Evaluating Greenland glacial isostatic adjustment corrections using
GRACE, altimetry and surface mass balance data.
Environmental Research Letters, 9(1):014004, 2014.
[ abstract |
bib |
http ]
|


HOME
Banquet Hall Reservation
Reserved By:
Date of Event:
Guest Name:
Time Of Event:
Organization:
Expected number of guest:
Type of Event:
Phone:
Contact person:
Email:
Set Up Requirements
Table Type:
Number of Tables:
Type of Room Required:
Classroom
Banquet
U Shaped
Meeting Hall
Number of Chairs per Table :
Other Requirements:
Paper/pen
Screen
Projector
Microphone
Napkins
Estimated Time To Decorate(in hours):
Arriving Date:-
Ending Time:-
Ending Date:-
Ending Time:-
Food Requirements:
Number of People:
Type Of Meal:
Breakfast
Lunch
Supper
Snacks/coffee/tea
Type of Service:
Buffet
Table Service
other
Submit
Reset
For more contact us


Laravel Crud Tools¶
Easy to use Laravel CRUD package with Controller, Model and Log system built in.
Table of contents¶
Installation¶
Install through composer using:
composer install thiagoprz\crud-tools
If you don’t have package auto discovery enabled add
CrudToolsServiceProvider to your config/app.php
:
...
'providers' => [
...
\Thiagoprz\CrudTools\CrudToolsServiceProvider::class,
],
...
Publish Crud Tools service provider to allow stubs customization:
php artisan vendor:publish --provider="Thiagoprz\CrudTools\CrudToolsServiceProvider"
Usage¶
CRUD Controller:¶
A CRUD Controller can be achieve by just creating a standard controller class using ControllerCrud trait.
The next step is to create a folder inside resources/views
with the
desired namespace or on root folder if the controller won’t be using a
specific namespace (admin on the example).
<?php
namespace App\Http\Controllers\Admin;
use App\Models\User;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Thiagoprz\CrudTools\Http\Controllers\ControllerCrud;
class UserController extends Controller
{
use ControllerCrud;
public $modelClass = User::class;
}
Views directory structure used by Controller CRUD based on the above example:
Folder: > views/admin/user
Files: > create.blade.php
edit.blade.php
Available vars: $model (the model being updated)
form.blade.php
Available vars: $model (the model being updated - only on edit action)
index.blade.php
Available vars: $items (the pagination object containing a filtered collection of the model)
show.blade.php
Available vars: $model (the model being displayed)
CRUD Model:¶
For models you just need to add the trait ModelCrud and after that create a static property declaring model’s validations (based on the create, update and/or delete scenarios), default order, filtering rules, upload file rules, define resources, and with / countable relationships.
Validations:
<?php ... use Thiagoprz\CrudTools\Models\ModelCrud; class User extends Authenticatable { use ModelCrud; /** * Model validations * * @var array */ static $validations = [ 'create' => [ 'name' => ['required', 'string', 'max:255'], 'email' => ['required', 'string', 'email', 'max:255', 'unique:users'], 'password' => ['required', 'string', 'min:8', 'confirmed'], ], 'update' => [ 'name' => ['required', 'string', 'max:255'], 'email' => ['required', 'string', 'email', 'max:255', 'unique:users'], 'password' => ['required', 'string', 'min:8', 'confirmed'], ], ]; ... }
Searchable fields:
You can create a $searchable property that will hold fields allowed to be searched on the static method search() - very useful with the ControllerCrud.
<?php
...
use Thiagoprz\CrudTools\Models\ModelCrud;
class User extends Authenticatable
{
use ModelCrud;
/**
* Fields that can be searched by (static)method search()
*
* @var array
*/
static $searchable = [
'id' => 'int',
'name' => 'string',
'created_at' => 'datetime',
];
...
}
Range searchable fields:
Types available: int, string, date, datetime and decimal.
You can use input filters using “from” and “to” suffix on date, datetime and decimal fields:
<!-- Filtering created_at usig field "from" ( where created_at >= $created_at_from ) -->
<label>Period from: </label>
<input type="date" name="created_at_from">
<!-- Filtering created_at usig field "to" ( where created_at <= $created_at_to ) -->
<label>To:</label>
<input type="date" name="created_at_to">
Type |
Description |
|
|---|---|---|
int |
Integer fields, can be used to search a range of records by using “from” and “to” suffixes |
Yes |
decimal |
Float, Double, Real or any decimal type of field. “from” and “to” suffixes allowed |
Yes |
string |
Any string field to be search using “WHERE field LIKE ‘%SEARCH%’” |
No |
string |
Any string field to be search using “WHERE field = ‘SEARCH’” |
No |
datetime |
Datetime and Timestamp fields |
Yes |
date |
Date fields |
Yes |
Custom searchable field methods:
In addition to use standard search based on type of fields you can add your on custom methods to customize search of specific fields. Create a method called “searchField” where Field is the name of the field with only first letter upper case.
Example:
<?php
...
use Thiagoprz\CrudTools\Models\ModelCrud;
class Books extends Model
{
...
/**
* Searching only by the start of the title of the book with LIKE
*/
public static function searchTitle($query, $title)
{
$query->where('title', 'LIKE', "$title%");
}
}
Sortable fields:
You can define the fields that will be used as default sorting of your model on the index action. Also, you can pass an “order” input used by the search method allowing the override the default order defined by this variable.
<?php
...
use Thiagoprz\CrudTools\Models\ModelCrud;
class Books extends Model
{
use ModelCrud;
/**
* Default order
*
* @var array
*/
static $search_order = [
'title' => 'ASC',
'updated_at' => 'DESC',
'created_at' => 'DESC',
];
...
}
Upload fields:
You can create a fileUploads method to define which and where your uploadable fields will store the files:
<?php
...
use Thiagoprz\CrudTools\Models\ModelCrud;
class User extends Authenticatable
{
use ModelCrud;
...
/**
* @param Campaign $model
* @return array
*/
public static function fileUploads(Campaign $model)
{
return [
'FIELD_NAME' => [
'path' => 'FOLDER', // Mandatory
'name' => 'FILE_NAME', // (OPTIONAL)if not provided will be the file original name
],
];
}
...
}
CRUD Generators¶
Controller Generator:¶
You can create a standard Controller to work with a model by using the following command:
php artisan make:crud-controller NAMESPACE1/NAMEController NAMESPACE2/Model
NAMESPACE1: Controller’s namespace
NAMEController: is the name of the controller
NAMESPACE2: Model’s namespace
Model: Name of the model
Model Generator:¶
To easily create a model with all Crud Tools enabled use:
php artisan make:crud-model NAMESPACE/Model
NAMESPACE: Model's namespace Model: Name of the model
Available options
–fillable: comma separated fields for fillable attributes
–searchable: comma separated fields for searchable attributes (based on search() method)
–primaryKey: field or comma separated fields that are the table’s primary key
–softDeletes: if passed enables SoftDeletes trait on class
–uploads: if passed adds fileUploads() method on class
–logable: adds Logable trait on model
Enabling Logs¶
To enable automatic logs on your models you need to publish Spatie Activity Logger migrations:
php artisan vendor:publish --provider="Spatie\Activitylog\ActivitylogServiceProvider" --tag="migrations"
Run migrations:
php artisan migrate
For more information you can read Spatie Activity Log Documentations.


CSS Transform property has it's own CSSStyleValue
type: CSSTransformValue
, and so it's subsequent values have their own type too. This is really nice because so far in javaScript, when we've wanted to modify one transform value, we've had to save and recreate a whole string if there have been multiple transform values affecting an element.
Take this CSS for example:
svg {
transform: rotate(25deg) scale(1.2);
}
If we want to change the rotate value we have to remember the scale value, so if we reset the transform it stays scaled at 1.2, otherwise we loose it:
const rotate = 30;
svgEl.style.transform = `rotate(${rotate}deg) scale(1.2)`;
This can get a little frustrating, especially if we have quite a few transform values and are only changing one.
It would be much better if each part could be built individually and automatically, as well as the overall transform, and with types rather than a string.
Well, with Typed OM, you can!
CSSTransformValue
This creates a new transform value, which takes an array of the transform value types. Let's see what our above example would look like:
const transform = new CSSTransformValue([
new CSSRotate(CSS.deg(30)),
new CSSScale(CSS.number(1.2))
])
Each different transform has it's own type, which takes relevant CSSNumericValue
s. Let's go through them.
CSSRotate
const rotate = new CSSRotate(CSS.deg(50));
/* Returns: CSSRotate
angle: CSSUnitValue
unit: "deg"
value: 50
is2D: true */
CSSScale
Scale can take two or three values. Two means it is scaled on a 2D plane, three in three dimensions.
const scale = new CSSScale(CSS.number(2), CSS.number(2));
/* Returns: CSSScale
is2D: true
x: CSSUnitValue {value: 2, unit: "number"}
y: CSSUnitValue {value: 2, unit: "number"}
z: CSSUnitValue {value: 1, unit: "number"} */
CSSSkew
There are 3 types of skew, as they all skew differently: CSSSkew
, CSSSkewX
and CSSSkewY
.
const skew = new CSSSkew(CSS.deg(10), CSS.deg(20));
/* Returns: CSSSKew
is2D: true
ax: CSSUnitValue {value: 10, unit: "deg"}
ay: CSSUnitValue {value: 20, unit: "deg"} */
const skewX = new CSSSkewX(CSS.grad(200));
/* Returns: CSSSKewX
is2D: true
ax: CSSUnitValue {value: 200, unit: "grad"} */
const skewY = new CSSSkewY(CSS.rad(1.3));
/* Returns: CSSSKewY
is2D: true
ax: CSSUnitValue {value: 1.3, unit: "rad"} */
CSSPerspective
const perspective = new CSSPerspective(CSS.px(50));
/* Returns: CSSPerspective
is2D: false
length: CSSUnitValue {value: 50, unit: "px"} */
CSSTranslate
The translate value can take two or three values. Two means it's a 2D transform, three means it is 3D.
const translate = new CSSTranslate(CSS.px(20), CSS.px(50));
/* Returns: CSSTranslate
is2D: true
x: CSSUnitValue {value: 20, unit: "px"}
y: CSSUnitValue {value: 50, unit: "px"}
z: CSSUnitValue {value: 0, unit: "px"} */
Notice how all the types require compatible CSSNumericValue
s. If you need a refresher on the transform property the documentation is here.
is2D
Note also the values that can transform in three dimensions. There's a boolean property on CSSTransformValue
and all the values we've seen above, to test if they return 2D or 3D.
const translate2d = new CSSTranslate(CSS.px(20), CSS.px(50));
let twodee = translate2d.is2D; // true
const translate3d = new CSSTranslate(CSS.px(20), CSS.px(50), CSS.px(-5));
twodee = translate3d.is2D; // false
toMatrix()
As well as the is2D
property there is a toMatrix()
method which returns the matrix
value of the given transform
value.
const transform = new CSSTransformValue([
new CSSRotate(CSS.deg(30)),
new CSSScale(CSS.number(1.2))
]);
const matrix = transform.toMatrix();
/* Returns: DOMMatrix
a: 1.0392304845413265
b: 0.5999999999999999
c: -0.5999999999999999
d: 1.0392304845413265
e: 0
f: 0
is2D: true
isIdentity: false
m11: 1.0392304845413265
m12: 0.5999999999999999
m13: 0
m14: 0
m21: -0.5999999999999999
m22: 1.0392304845413265
m23: 0
m24: 0
m31: 0
m32: 0
m33: 1
m34: 0
m41: 0
m42: 0
m43: 0
m44: 1 */
This can appear a little overwhelming as it's returning both the 2D matrix (a-f) and the 3D matrix (m11 - m44).
Now we've seen all the types, let's put them into practise with an example in the next section


Ethereum (ETH) Price Weekly Forecast: Crucial Support At Risk
- ETH price is facing a strong resistance near the $184 and $185 levels against the US Dollar.
- The price is trading above the key $178 support, which remains at a risk.
- There is a crucial bearish trend line forming with resistance near $186 on the 4-hours chart of ETH/USD (data feed via Kraken).
- The pair is currently declining and it might struggle to clear the $178 and $176 support levels.
Ethereum price is showing bearish signs below $185 against the US Dollar, similar to bitcoin. ETH price remains at a risk of a downside break below the $176 support area.
Ethereum Price Weekly Analysis
This past week, Ethereum retested the key $190 resistance area against the US Dollar. However, ETH price failed to continue higher, resulting in a fresh decline below the $188 support area.
Moreover, there was a break below the key $186 support area. Finally, there was a close below the $184 support and the 100 simple moving average (4-hours). The bears gained pace below the $180 level and a low was formed near the $177 level.
It seems like the $176-$178 support area is playing a crucial role for the bulls. Recently, there was an upside correction above the $180 level. Furthermore, there was a break above the 23.6% Fib retracement level of the downward move from the $190 swing high to $177 low.
On the upside, Ethereum price seems to be facing a strong resistance near the $184 level and the 100 SMA. The 50% Fib retracement level of the downward move from the $190 swing high to $177 low is also near the $184 level.
More importantly, there is a crucial bearish trend line forming with resistance near $186 on the 4-hours chart of ETH/USD. Therefore, the price is likely to face a strong resistance, starting with $184 and up to $186.
Having said that, the price must settle above the $188 and $190 resistance levels to move into a positive zone. The next key resistances are near the $200 and $205 levels.
On the downside, there are many key supports near the $178 and $176 levels. If there is a daily close below the $176 support, the price could decline heavily. The next major support are near the $165 and $160 levels.
The above chart indicates that Ethereum price is clearly declining towards the $176 support area. Thus, it might either recover nicely above $185 or extend its decline towards $165.
Technical Indicators
4 hours MACD – The MACD for ETH/USD is slowly moving into the bearish zone.
4 hours RSI – The RSI for ETH/USD is currently below the 50 level, with a bearish angle.
Major Support Level – $176
Major Resistance Level – $188


Next: set-difference, Previous: adjoin, Up: Conses Dictionary
pushnew
item place &key key test test-not
⇒ new-place-value
item—an object.
place—a place, the value of which is a proper list.
test—a designator for a function of two arguments that returns a generalized boolean.
test-not—a designator for a function of two arguments that returns a generalized boolean.
key—a designator for a function of one argument, or nil.
new-place-value—a list (the new value of place).
pushnew tests whether item is the same as any existing element of the list stored in place. If item is not, it is prepended to the list, and the new list is stored in place.
pushnew returns the new list that is stored in place.
Whether or not item is already a member of the list that is in place is determined by comparisons using :test or :test-not. The first argument to the :test or :test-not function is item; the second argument is an element of the list in place as returned by the :key function (if supplied).
If :key is supplied, it is used to extract the part to be tested from both item and the list element, as for adjoin.
The argument to the :key function is an element of the list stored in place. The :key function typically returns part part of the element of the list. If :key is not supplied or nil, the list element is used.
For information about the evaluation of subforms of place, see Evaluation of Subforms to Places.
It is implementation-dependent whether or not pushnew actually executes the storing form for its place in the situation where the item is already a member of the list held by place.
(setq x '(a (b c) d)) ⇒ (A (B C) D) (pushnew 5 (cadr x)) ⇒ (5 B C) x ⇒ (A (5 B C) D) (pushnew 'b (cadr x)) ⇒ (5 B C) x ⇒ (A (5 B C) D) (setq lst '((1) (1 2) (1 2 3))) ⇒ ((1) (1 2) (1 2 3)) (pushnew '(2) lst) ⇒ ((2) (1) (1 2) (1 2 3)) (pushnew '(1) lst) ⇒ ((1) (2) (1) (1 2) (1 2 3)) (pushnew '(1) lst :test 'equal) ⇒ ((1) (2) (1) (1 2) (1 2 3)) (pushnew '(1) lst :key #'car) ⇒ ((1) (2) (1) (1 2) (1 2 3))
The contents of place may be modified.
push, adjoin, Generalized Reference
The effect of
(pushnew item place :test p)
is roughly equivalent to
(setf place (adjoin item place :test p))
except that the subforms of place are evaluated only once, and item is evaluated before place.
Next: set-difference, Previous: adjoin, Up: Conses Dictionary


ASDisplayNode Class Reference
| Inherits from | ASDealloc2MainObject |
|---|---|
| Conforms to | ASLayoutElement |
| Declared in | ASDisplayNode.h |
Overview
An ASDisplayNode
is an abstraction over UIView
and CALayer
that allows you to perform calculations about a view
hierarchy off the main thread, and could do rendering off the main thread as well.
The node API is designed to be as similar as possible to UIView
. See the README for examples.
Subclassing
ASDisplayNode
can be subclassed to create a new UI element. The subclass header ASDisplayNode+Subclasses
provides
necessary declarations and conveniences.
Commons reasons to subclass includes making a UIView
property available and receiving a callback after async
display.
Initializing a node object
– init
Designated initializer.
- (instancetype)init
Return Value
An ASDisplayNode instance whose view will be a subclass that enables asynchronous rendering, and passes through -layout and touch handling methods.
Declared In
ASDisplayNode.h
– initWithViewBlock:
Alternative initializer with a block to create the backing view.
- (instancetype)initWithViewBlock:(ASDisplayNodeViewBlock)viewBlock
Parameters
viewBlock |
The block that will be used to create the backing view. |
|---|
Return Value
An ASDisplayNode instance that loads its view with the given block that is guaranteed to run on the main queue. The view will render synchronously and -layout and touch handling methods on the node will not be called.
Declared In
ASDisplayNode.h
– initWithViewBlock:didLoadBlock:
Alternative initializer with a block to create the backing view.
- (instancetype)initWithViewBlock:(ASDisplayNodeViewBlock)viewBlock didLoadBlock:(nullable ASDisplayNodeDidLoadBlock)didLoadBlock
Parameters
viewBlock |
The block that will be used to create the backing view. |
|---|---|
didLoadBlock |
The block that will be called after the view created by the viewBlock is loaded |
Return Value
An ASDisplayNode instance that loads its view with the given block that is guaranteed to run on the main queue. The view will render synchronously and -layout and touch handling methods on the node will not be called.
Declared In
ASDisplayNode.h
– initWithLayerBlock:
Alternative initializer with a block to create the backing layer.
- (instancetype)initWithLayerBlock:(ASDisplayNodeLayerBlock)layerBlock
Parameters
layerBlock |
The block that will be used to create the backing layer. |
|---|
Return Value
An ASDisplayNode instance that loads its layer with the given block that is guaranteed to run on the main queue. The layer will render synchronously and -layout and touch handling methods on the node will not be called.
Declared In
ASDisplayNode.h
– initWithLayerBlock:didLoadBlock:
Alternative initializer with a block to create the backing layer.
- (instancetype)initWithLayerBlock:(ASDisplayNodeLayerBlock)layerBlock didLoadBlock:(nullable ASDisplayNodeDidLoadBlock)didLoadBlock
Parameters
layerBlock |
The block that will be used to create the backing layer. |
|---|---|
didLoadBlock |
The block that will be called after the layer created by the layerBlock is loaded |
Return Value
An ASDisplayNode instance that loads its layer with the given block that is guaranteed to run on the main queue. The layer will render synchronously and -layout and touch handling methods on the node will not be called.
Declared In
ASDisplayNode.h
– onDidLoad:
Add a block of work to be performed on the main thread when the node’s view or layer is loaded. Thread safe.
- (void)onDidLoad:(ASDisplayNodeDidLoadBlock)body
Parameters
body |
The work to be performed when the node is loaded. @precondition The node is not already loaded. |
|---|
Discussion
Warning: Be careful not to retain self in body
. Change the block parameter list to ^(MYCustomNode *self) {}
if you
want to shadow self (e.g. if calling this during init
).
Note: This will only be called the next time the node is loaded. If the node is later added to a subtree of a node
that has shouldRasterizeDescendants=YES
, and is unloaded, this block will not be called if it is loaded again.
Declared In
ASDisplayNode.h
synchronous
Returns whether the node is synchronous.
@property (nonatomic, readonly, assign, getter=isSynchronous) BOOL synchronous
Return Value
NO if the node wraps a _ASDisplayView, YES otherwise.
Declared In
ASDisplayNode.h
Getting view and layer
view
Returns a view.
@property (nonatomic, readonly, strong) UIView *view
Discussion
The view property is lazily initialized, similar to UIViewController. To go the other direction, use ASViewToDisplayNode() in ASDisplayNodeExtras.h.
Warning: The first access to it must be on the main thread, and should only be used on the main thread thereafter as well.
Declared In
ASDisplayNode.h
nodeLoaded
Returns whether a node’s backing view or layer is loaded.
@property (nonatomic, readonly, assign, getter=isNodeLoaded) BOOL nodeLoaded
Return Value
YES if a view is loaded, or if layerBacked is YES and layer is not nil; NO otherwise.
Declared In
ASDisplayNode.h
layerBacked
Returns whether the node rely on a layer instead of a view.
@property (nonatomic, assign, getter=isLayerBacked) BOOL layerBacked
Return Value
YES if the node rely on a layer, NO otherwise.
Declared In
ASDisplayNode.h
layer
Returns a layer.
@property (nonatomic, readonly, strong) CALayer *layer
Discussion
The layer property is lazily initialized, similar to the view property. To go the other direction, use ASLayerToDisplayNode() in ASDisplayNodeExtras.h.
Warning: The first access to it must be on the main thread, and should only be used on the main thread thereafter as well.
Declared In
ASDisplayNode.h
visible
Returns YES if the node is – at least partially – visible in a window.
@property (readonly, getter=isVisible) BOOL visible
Declared In
ASDisplayNode.h
inPreloadState
Returns YES if the node is in the preloading interface state.
@property (readonly, getter=isInPreloadState) BOOL inPreloadState
Declared In
ASDisplayNode.h
inDisplayState
Returns YES if the node is in the displaying interface state.
@property (readonly, getter=isInDisplayState) BOOL inDisplayState
Declared In
ASDisplayNode.h
interfaceState
Returns the Interface State of the node.
@property (readonly) ASInterfaceState interfaceState
Return Value
The current ASInterfaceState of the node, indicating whether it is visible and other situational properties.
See Also
Declared In
ASDisplayNode.h
Managing dimensions
– layoutThatFits:
Asks the node to return a layout based on given size range.
- (ASLayout *)layoutThatFits:(ASSizeRange)constrainedSize
Parameters
constrainedSize |
The minimum and maximum sizes the receiver should fit in. |
|---|
Return Value
An ASLayout instance defining the layout of the receiver (and its children, if the box layout model is used).
Discussion
Though this method does not set the bounds of the view, it does have side effects–caching both the constraint and the result.
Warning: Subclasses must not override this; it caches results from -calculateLayoutThatFits:. Calling this method may be expensive if result is not cached.
Declared In
ASDisplayNode.h
layoutSpecBlock
Provides a way to declare a block to provide an ASLayoutSpec without having to subclass ASDisplayNode and implement layoutSpecThatFits:
@property (nonatomic, readwrite, copy, nullable) ASLayoutSpecBlock layoutSpecBlock
Return Value
A block that takes a constrainedSize ASSizeRange argument, and must return an ASLayoutSpec that includes all of the subnodes to position in the layout. This input-output relationship is identical to the subclass override method -layoutSpecThatFits:
Discussion
Warning: Subclasses that implement -layoutSpecThatFits: must not also use .layoutSpecBlock. Doing so will trigger an exception. A future version of the framework may support using both, calling them serially, with the .layoutSpecBlock superseding any values set by the method override.
Declared In
ASDisplayNode.h
calculatedSize
Return the calculated size.
@property (nonatomic, readonly, assign) CGSize calculatedSize
Return Value
Size already calculated by -calculateLayoutThatFits:.
Discussion
Ideal for use by subclasses in -layout, having already prompted their subnodes to calculate their size by calling -measure: on them in -calculateLayoutThatFits.
Warning: Subclasses must not override this; it returns the last cached measurement and is never expensive.
Declared In
ASDisplayNode.h
constrainedSizeForCalculatedLayout
Return the constrained size range used for calculating layout.
@property (nonatomic, readonly, assign) ASSizeRange constrainedSizeForCalculatedLayout
Return Value
The minimum and maximum constrained sizes used by calculateLayoutThatFits:.
Declared In
ASDisplayNode.h
Managing the nodes hierarchy
– addSubnode:
Add a node as a subnode to this node.
- (void)addSubnode:(ASDisplayNode *)subnode
Parameters
subnode |
The node to be added. |
|---|
Discussion
The subnode’s view will automatically be added to this node’s view, lazily if the views are not created yet.
Declared In
ASDisplayNode.h
– insertSubnode:belowSubnode:
Insert a subnode before a given subnode in the list.
- (void)insertSubnode:(ASDisplayNode *)subnode belowSubnode:(ASDisplayNode *)below
Parameters
subnode |
The node to insert below another node. |
|---|---|
below |
The sibling node that will be above the inserted node. |
Discussion
If the views are loaded, the subnode’s view will be inserted below the given node’s view in the hierarchy even if there are other non-displaynode views.
Declared In
ASDisplayNode.h
– insertSubnode:aboveSubnode:
Insert a subnode after a given subnode in the list.
- (void)insertSubnode:(ASDisplayNode *)subnode aboveSubnode:(ASDisplayNode *)above
Parameters
subnode |
The node to insert below another node. |
|---|---|
above |
The sibling node that will be behind the inserted node. |
Discussion
If the views are loaded, the subnode’s view will be inserted above the given node’s view in the hierarchy even if there are other non-displaynode views.
Declared In
ASDisplayNode.h
– insertSubnode:atIndex:
Insert a subnode at a given index in subnodes.
- (void)insertSubnode:(ASDisplayNode *)subnode atIndex:(NSInteger)idx
Parameters
subnode |
The node to insert. |
|---|---|
idx |
The index in the array of the subnodes property at which to insert the node. Subnodes indices start at 0 and cannot be greater than the number of subnodes. |
Discussion
If this node’s view is loaded, ASDisplayNode insert the subnode’s view after the subnode at index - 1’s view even if there are other non-displaynode views.
Declared In
ASDisplayNode.h
– replaceSubnode:withSubnode:
Replace subnode with replacementSubnode.
- (void)replaceSubnode:(ASDisplayNode *)subnode withSubnode:(ASDisplayNode *)replacementSubnode
Parameters
subnode |
A subnode of self. |
|---|---|
replacementSubnode |
A node with which to replace subnode. |
Discussion
Should both subnode and replacementSubnode already be subnodes of self, subnode is removed and replacementSubnode inserted in its place. If subnode is not a subnode of self, this method will throw an exception. If replacementSubnode is nil, this method will throw an exception
Declared In
ASDisplayNode.h
– removeFromSupernode
Remove this node from its supernode.
- (void)removeFromSupernode
Discussion
The node’s view will be automatically removed from the supernode’s view.
Declared In
ASDisplayNode.h
subnodes
The receiver’s immediate subnodes.
@property (nonatomic, readonly, copy) NSArray<ASDisplayNode*> *subnodes
Declared In
ASDisplayNode.h
supernode
The receiver’s supernode.
@property (nonatomic, readonly, weak) ASDisplayNode *supernode
Declared In
ASDisplayNode.h
Drawing and Updating the View
displaysAsynchronously
Whether this node’s view performs asynchronous rendering.
@property (nonatomic, assign) BOOL displaysAsynchronously
Return Value
Defaults to YES, except for synchronous views (ie, those created with -initWithViewBlock: / -initWithLayerBlock:), which are always NO.
Discussion
If this flag is set, then the node will participate in the current asyncdisplaykit_async_transaction and do its rendering on the displayQueue instead of the main thread.
Asynchronous rendering proceeds as follows:
When the view is initially added to the hierarchy, it has -needsDisplay true. After layout, Core Animation will call -display on the _ASDisplayLayer -display enqueues a rendering operation on the displayQueue When the render block executes, it calls the delegate display method (-drawRect:… or -display) The delegate provides contents via this method and an operation is added to the asyncdisplaykit_async_transaction Once all rendering is complete for the current asyncdisplaykit_async_transaction, the completion for the block sets the contents on all of the layers in the same frame
If asynchronous rendering is disabled:
When the view is initially added to the hierarchy, it has -needsDisplay true. After layout, Core Animation will call -display on the _ASDisplayLayer -display calls delegate display method (-drawRect:… or -display) immediately -display sets the layer contents immediately with the result
Note: this has nothing to do with -[CALayer drawsAsynchronously].
Declared In
ASDisplayNode.h
shouldRasterizeDescendants
Whether to draw all descendant nodes' layers/views into this node’s layer/view’s backing store.
@property (nonatomic, assign) BOOL shouldRasterizeDescendants
Declared In
ASDisplayNode.h
displaySuspended
Prevent the node’s layer from displaying.
@property (nonatomic, assign) BOOL displaySuspended
Discussion
A subclass may check this flag during -display or -drawInContext: to cancel a display that is already in progress.
Defaults to NO. Does not control display for any child or descendant nodes; for that, use -recursivelySetDisplaySuspended:.
If a setNeedsDisplay occurs while displaySuspended is YES, and displaySuspended is set to NO, then the layer will be automatically displayed.
Declared In
ASDisplayNode.h
shouldAnimateSizeChanges
Whether size changes should be animated. Default to YES.
@property (nonatomic, assign) BOOL shouldAnimateSizeChanges
Declared In
ASDisplayNode.h
– recursivelySetDisplaySuspended:
Prevent the node and its descendants' layer from displaying.
- (void)recursivelySetDisplaySuspended:(BOOL)flag
Parameters
flag |
YES if display should be prevented or cancelled; NO otherwise. |
|---|
See Also
Declared In
ASDisplayNode.h
– recursivelyClearContents
Calls -clearContents on the receiver and its subnode hierarchy.
- (void)recursivelyClearContents
Discussion
Clears backing stores and other memory-intensive intermediates. If the node is removed from a visible hierarchy and then re-added, it will automatically trigger a new asynchronous display, as long as displaySuspended is not set. If the node remains in the hierarchy throughout, -setNeedsDisplay is required to trigger a new asynchronous display.
See Also
@property displaySuspended and setNeedsDisplay
Declared In
ASDisplayNode.h
– recursivelyClearFetchedData
Calls -clearFetchedData on the receiver and its subnode hierarchy.
- (void)recursivelyClearFetchedData
Discussion
Clears any memory-intensive fetched content. This method is used to notify the node that it should purge any content that is both expensive to fetch and to retain in memory.
Declared In
ASDisplayNode.h
– recursivelyFetchData
Calls -fetchData on the receiver and its subnode hierarchy.
- (void)recursivelyFetchData
Discussion
Fetches content from remote sources for the current node and all subnodes.
Declared In
ASDisplayNode.h
– setNeedsDataFetch
Triggers a recursive call to fetchData when the node has an interfaceState of ASInterfaceStatePreload
- (void)setNeedsDataFetch
Declared In
ASDisplayNode.h
placeholderEnabled
Toggle displaying a placeholder over the node that covers content until the node and all subnodes are displayed.
@property (nonatomic, assign) BOOL placeholderEnabled
Discussion
Defaults to NO.
Declared In
ASDisplayNode.h
placeholderFadeDuration
Set the time it takes to fade out the placeholder when a node’s contents are finished displaying.
@property (nonatomic, assign) NSTimeInterval placeholderFadeDuration
Discussion
Defaults to 0 seconds.
Declared In
ASDisplayNode.h
drawingPriority
Determines drawing priority of the node. Nodes with higher priority will be drawn earlier.
@property (nonatomic, assign) NSInteger drawingPriority
Discussion
Defaults to ASDefaultDrawingPriority. There may be multiple drawing threads, and some of them may decide to perform operations in queued order (regardless of drawingPriority)
Declared In
ASDisplayNode.h
Hit Testing
hitTestSlop
Bounds insets for hit testing.
@property (nonatomic, assign) UIEdgeInsets hitTestSlop
Discussion
When set to a non-zero inset, increases the bounds for hit testing to make it easier to tap or perform gestures on this node. Default is UIEdgeInsetsZero.
This affects the default implementation of -hitTest and -pointInside, so subclasses should call super if you override it and want hitTestSlop applied.
Declared In
ASDisplayNode.h
– pointInside:withEvent:
Returns a Boolean value indicating whether the receiver contains the specified point.
- (BOOL)pointInside:(CGPoint)point withEvent:(nullable UIEvent *)event
Parameters
point |
A point that is in the receiver’s local coordinate system (bounds). |
|---|---|
event |
The event that warranted a call to this method. |
Return Value
YES if point is inside the receiver’s bounds; otherwise, NO.
Discussion
Includes the “slop” factor specified with hitTestSlop.
Declared In
ASDisplayNode.h
Converting Between View Coordinate Systems
– convertPoint:toNode:
Converts a point from the receiver’s coordinate system to that of the specified node.
- (CGPoint)convertPoint:(CGPoint)point toNode:(nullable ASDisplayNode *)node
Parameters
point |
A point specified in the local coordinate system (bounds) of the receiver. |
|---|---|
node |
The node into whose coordinate system point is to be converted. |
Return Value
The point converted to the coordinate system of node.
Declared In
ASDisplayNode.h
– convertPoint:fromNode:
Converts a point from the coordinate system of a given node to that of the receiver.
- (CGPoint)convertPoint:(CGPoint)point fromNode:(nullable ASDisplayNode *)node
Parameters
point |
A point specified in the local coordinate system (bounds) of node. |
|---|---|
node |
The node with point in its coordinate system. |
Return Value
The point converted to the local coordinate system (bounds) of the receiver.
Declared In
ASDisplayNode.h
– convertRect:toNode:
Converts a rectangle from the receiver’s coordinate system to that of another view.
- (CGRect)convertRect:(CGRect)rect toNode:(nullable ASDisplayNode *)node
Parameters
rect |
A rectangle specified in the local coordinate system (bounds) of the receiver. |
|---|---|
node |
The node that is the target of the conversion operation. |
Return Value
The converted rectangle.
Declared In
ASDisplayNode.h
– convertRect:fromNode:
Converts a rectangle from the coordinate system of another node to that of the receiver.
- (CGRect)convertRect:(CGRect)rect fromNode:(nullable ASDisplayNode *)node
Parameters
rect |
A rectangle specified in the local coordinate system (bounds) of node. |
|---|---|
node |
The node with rect in its coordinate system. |
Return Value
The converted rectangle.
Declared In
ASDisplayNode.h


Dinosaur (2000) 3 1/2 stars out of 4. Featuring the vocal talents of D.B. Sweeney, Ossie Davis, Alfre Woodard, Max Casella, Hayden Panettier, Julianna Margulies, Joan Plowrightand Della Reese
Disney's latest creation, "Dinosaur," is a magical meld of digitally enhanced live-action photography, special effects and computer animated wonder.
Though a bit ragged on the technical side, the film showcases a simple story with a moral that the younger members of the audience can understand and appreciate, plus some heroic and amusing characters with whom they can relate.
The story is reminiscent of the animated "Land Before Time" of several years ago: A group of dinosaurs seek a legendary verdant valley containing enough food and water to sustain them.
"Dinosaur" follows the adventures of an Iguanodon named Aladar (voiced by D.B. Sweeney) who is separated from his own species as a hatchling and adopted by a tribe of Lemurs.
Years later, a catastrophic event forces the family to flee and join up with a herd of dinosaurs searching for a safe nesting ground.
In a sense, the movie is anti-Darwinian. Its message that survival of the fittest is a brutal misconception, while standing together and cooperation - the mighty protecting the weak - makes for a more viable and stronger community, is a lesson the children will easily grasp.
Moreso than the special effects, it is the characters who drive "Dinosaur."
Besides Aladar, there is his Lemur parents, Yar (Ossie Davis) and Plio (Alfre Woodard); his best pal, Zini (Max Casella); sister, Suri (Hayden Panettiere); and the friends they make on the trek, Neera (Julianna Margulies), another Iguanodon; Baylene (Joan Plowright), an elderly, dignified Brachiosuar; and Eema (Della Reese), a gruff, but lovable Styrachosaur.
The movie's real stars, though, are the various technicians who recreated the world of 65 million years ago. Though the effects are sometimes dark and murky, the Disney team has created such fully-developed creatures, plus some beautiful vistas that you tend to gloss over the rough spots.
Aided by a rousing score by James Newton Howard, which contains echoes of a previous Disney winner, "The Lion King," "Dinosaur" is a movie that will engross the younger set.
One concession I really appreciated is that none of the dinosaurs nor Lemurs break into song and dance. That would have been a bit too much, even for an animated feature.
Though it contains some violence, "Dinosaur" is basically a good-hearted saga, and at a little under 90 minutes, it will hold the attention of the youngest viewer.
"Dinosaur" is basically a family movie.  And an entertaining movie with a moral is always a good bet for a family outing.
"Dinosaur" is not as colorful as "Tarzan," nor does it pack the emotional wallop of "The Lion King, "but it does provide breathtaking scenery, the latest in special effects and lovable characters.
You can't lose with this combination.
Bob Bloom is the film critic at the Journal and Courier in Lafayette, IN. He can be reached by e-mail at<EMAIL_ADDRESS>or at<EMAIL_ADDRESS>Reviews by Bloom, an associate member of the Online Film Critics Society, are posted on the Internet Movie Database at: http://www.imdb.com/M/reviews_by?Bob+Bloom
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


How do we incorporate magic into our business?Our listeners have been loving the
“woo” we bring to our episodes (tarot, manifestation, intention-setting, etc), so today we’re talking about practical ways
we bring magic and intention into our businesses
MELISSA HARTWIG, WHOLE30 CO-CREATOR AND #1 NEW YORK TIMES BEST-SELLING AUTHOR
S2 E6: Building a Brand
You know we love a good brand story, and as it turns out, a solid brand is probably the number 1 piece of the puzzle that’s lending to the success of Almanac Supply Co. So in this episode of Making a Business, we're digging into how Emily has established a brand for her business—what this means for her personal brand, how she's gathered community around it, and the importance of maintaining professionalism while still being personable as a retail business owner.
Category: Business / Self development
Guests:N/A


{% extends "global/Base.html" %} {% load staticfiles otree_tags %} {% block title %} Results {% endblock %} {% block content %}
{% if same_choice %} Both of you chose {{ player.decision }}. {% else %} You chose {{ player.decision }}; the other player chose {{ player.other_player.decision }}. {% endif %}
As a result, you made {{ player.payoff }}.
{% next_button %} {% endblock %}


Eating delicious food and traveling are my goals in life!
Everybody's got plans... until they get hit.