Nominal, Ordinal, Interval, and Ratio Typologies are Misleading¶
P. F. Velleman and L. Wilkinson, “Nominal, Ordinal, Interval, and Ratio Typologies are Misleading,” The American Statistician, vol. 47, no. 1, pp. 65–72, Feb. 1993.
本文共分成 15 小节来说明 S. S. Stevens 的类型系统是误导人的。 在我看来其实只有一个方面，就是 – 数据属性的类型应该由其在具体问题中的具体含义来决定。
不过我觉得这篇文章写得非常值得学习一下。
首先陈述 S. S. Stevens 的类型系统:
In the early 1940s, the Harvard psychophysicist S. S. Stenvens coined the term nominal, ordinal, interval, and ratio to describe a hierarchy of measurement scales [1] used in psychophysics, and classified statistical procedures according to the scales for which they were “permissible.”
然后抛出自己的观点:
Unfortunately, the use of Stevens’s categories in selecting or recommending statistical analysis method is in appropriate and can often be wrong. They do not describe the attributes of real data that is essential to good statistical analysis. Nor do they provides a classification scheme appropriate for modern data analysis methods.
第一节 Steven’s Typology of Data¶
以下是具体的分析，其实 Stevens 的有些观点是蛮有意思的：
… Stevens presented a hierarchy of data scales based on invariance of their meaning under different classes of transformations.
… Measurement scales that preserve meaning under a wide variety of transformations in some sense convey less information than those whose meaning is preserved by only a restricted class of transformations.
… Stevens called such a scale ordinal if any transformation of the scale value that preserves their numerical order produces another scale that shares the same one-to-one relation between comparisons among objects and comparisons among corresponding scale values. … Stevens used the term permissible to describe the set of transformation that preserves the …
… Interval scales involves a difference (-) instead of order (>) operator, … Thus linear transformation … are permissible for interval scale data, but we may not, for example, take logs. This is a smaller class of permissible transformation than for ordinal data, suggesting that in some sense the data values carry more information. … Ratio scales preserve relative ratios, … Ratio scale data have a defined zero, which may not be changed. Nominal scales … do not even require … numerical values, but only of unique identifiers. They are invariant under any transformation that preserves the relationship between individuals and their identifiers. … Of course, only the weakest kind of information can survive such arbitrary transformations.
几个问题的定义
- Representation problem
- Measurement theorists call the issue involved in assigning scale values to observations the representation problem.
- Uniqueness problem
- They call the invariance of scales under transformations the uniqueness problem.
- Meaningfulness problem
- Determining the truth or falsity of statements based on comparisons of assigned scale values has been called the meaningfulness problem. [2]
第二节 Prescribing and Proscribing statistics¶
这一节说的是 Stevens 不仅把他的理念用在一些简单的的运算之上，而是扩展到了 statistical procedures 上面
He classified not just simple operations, but also statistical procedures according to the scales for which they were “permissible.” A scale that preserves meaning under some class of transformations should, … be restricted to statistics whose meaning would not change were any of those transformations applied to the data.
上面那句英语，我没看懂 :( 我英语不够好。吐槽一下，现在的文章质量普遍在下降，虽然对现在的我来说不见得是件坏事，但实际上是。 下面的举例可以让我稍微理解一下:
By this reasoning, analyses on nominal data, for example, should be limited to summary statistics such as the numbers of cases, the mode, and contingency correlation, which require only that the identity of the values be preserved. Permissible statistics of ordinal scales included these plus the median, percentiles, and ordinal correlations, that is, statistics whose meanings are preserved when monotone transformations are applied to data. Interval data allowed, in addition, means, standard deviations (although not all common statistics computed with standard deviations), and product moment correlations, becasuse the interpretations of these statistics are unchanged when linear transformations are applied to the data. Finally ratio data allowed all of these plus geometrical means and coefficients of variation, which are unchanged by rescaling the data.
看了上面的举例解释，我理解了，稍微该成我理解的形式， A scale that preserves meaning under some class of transformations should be restricted to statistics whose meaning would not change when any of those transformations were applied to the data.
我感觉我主要是在学英语，哈哈！Luce 的总结更加简洁，
… the scale type places [limitations] upon the statistics one may sensibly employ. If the interpretation of a particular statistic or statistical test is altered when admissible scale transformations are applied, then our substantive conclusion will depend on which arbitrary representation we have used in making our calculations. Most scientists, when they understand the problem, feel that they should shun such statistics and rely only upon those that exhibit the appropriate invariances for the scale type at hand.
我都被说服了，上面说的这有什么不对的吗，不变是多么美好的性质。
第三节 Classical Criticisms of Stevens’s Proscriptions¶
有个反驳的例子很好玩，先引用下主要观点
First, restricting the choice of statistical choice to those that “exhibit the appropriate invariances for the scale type at hand” is a dangerous practice for data analysis; Second, his taxonomy is too strict to apply to real-world data. Third, Stevens’s proscriptions often lead to degrading data by rank ordering and unnecessarily resorting to nonparametric methods.
Todo
什么是 nonparametric methods ? 了解一下
我以为一下这些观点是主要的反驳立场了
Lord (1953) show that the choice of permissible statistical tests for a given set of data does not depend on the representation or uniqueness problems, but is concerned instead with meaningfulness.
Guttman (1977) argued more generally that the statistical interpretation of data depends on the question asked of the data and on the kind of evidence that we would accept to inform us about that question. He defines this evidence in terms of the loss function chosen to fit a model.
好玩的例子:
His note imagined the accusation that a professor who owned the university “football jersey number concession” had peddled unusually low numbers to the Freshman class. Although Lord’s professor protests that football numbers are only nominal-scale values, the statisticians he consults is happy to add them up, square them, compute their mean, and perform other operations needed for the application of Tchebycheff’s inequality [3] (avoiding reference to normality) to test the accusation that the numbers were “too low”. When the professor protests that these were nominal “football numbers,” the statistician remarks that “the numbers don’t know where they came from” — a remark that, in retrospect, may have been a bit too glib for the seriousness of Lord’s point.
其实我认为，也许问题主要在于：“所谓的 data 的 meaning 发生在什么地方？” 按照本文的说法，Stevens 的说法过于把数据的意义固定于所考察对象的常见意义（见下面的引用），比如足球服的号码主要是用来区分球员，在这个意义下，数字的大小的确没有意义。 如果学校里的那些新生关注的是这些球衣能否有效的把他们区分开来，那么这个意义是没毛病的。 但是，如果新生们对数字有偏好，那么球衣号码的大小就有了意义，这其实已经是另一回事了。
(Tukey, 1961) The thus summarized [by Luce] is a dangerous one … Results based on approximate foundations must be used with underlying approximation in mind. Those who seek certainty rather than truth will try to avoid this fact. But what knowledge is not ultimately based on some approximation? And what progress has been made, except with the use of such knowledge.
最后一句其实也许有点问题，如果到不了彼岸，倒也没什么，approximation 就是我们借助的舟。 可要是到了彼岸呢，我抛弃这个 approximate 的工具有什么问题。 再说了，certainty 和 truth 有绝对矛盾的地方吗 ？绝对的真理也许绝对确定，而在不确定中建立的真理，是否真理本身的意义就在于不确定呢？比如海森堡测不准？ 这个反驳也许有点过头了。
事实上 Stevens 自己也承认，
there can be a kind of pragmatic sanction: in numerous instances it leads to fruitful results.
所以也可以反过来说，Stevens 的观点也没有那么绝对，他只是没有明确意识到 meaning 真正产生的那个地方。
第四节 Controversy over Statistics and Scale Types¶
measurement theorist （这是什么理论专家，测度理论专家？）通常总结到 statistical methods must be constrained by the scale type of the data. 本文的立场主要是在“如何看待理论测度在统计上应用时，是否可以用 scale type 来选择统计方法上”的。其反对的主要理由在于，这样做在实际过程中行不通。
The differences in viewpoint stem in part from a fundamental difference between mathematics and science. Tukey (1962) noted this difference in separating data analysis from mathematical statistics:
There are diverse views as to what makes a science, but three constituents will be judged by most, viz:
- (a1) intellectual content;
- (a2) organization into an understandable form;
- (a3) reliance upon the test of experience as the ultimate standard of validity
By these tests, mathematics is not a science, since its ultimate standard of validity is an agree-upon sort of logical consistency and provability.
第五节 Alternative Scale Taxonomies¶
这一节的主要观点是，还存在其他的分类方式，而且这些分类方式并不限制可以使用的 transformations, 而且也从来没有宣称包含了一切可能性，只是作为某种 first aid ways to transform data values, 这些 transformation 甚至包含将一种类型的的数据通过转换迁移到另一种数据。 比如这里面有一种叫做 counted fractions 的类型，也就是在 0 和 1 之内的 ratio. 对于这个类型的数据，要放到 Stevens 四种类型中的哪一种之中呢？因为它要求的 0 和 1 边界不允许任何 scale shift.
第六节 Proscribing Transformations¶
很多 transformations 像 logarithm 和 powers 实际上是很常用的。 然而根据 Stevens 的理论，这些 transformations 只能用在 ordinal 和 nominal 类型的数据上，这显然是不太合理的。
There is no reason to believe that data come to us measured in the “best” way.
Abelson and Tukey … criticized the tendency of scale-driven choice of statistics to select nonparametric methods, not because they lack power, but “because they are poorly adapted to the variety of uses one requires for good insight into bodies of data”
第七节 Good Data Analysis Does NOT Assume Data Types¶
Things are seldom what they seem.
Data that appear to have one type in fact hide other information
上面的第二句话有个例子，零售店的结账口一般来说是有标号的，这些标号可以认为是 nominal 的，因为它们只是用来区分不同的结账口。 但不可否认的是，具有以下这种可能性，这些带有顺序的 ID 号和结账口之间的开张顺序是相对应的，据此，我们也许可以来探索 ID 号和其他一些重要变量之间的联系。
我个人认为，这个还是很有道理的，虽然一个超级强大的学习机面对即使是乱排的 ID 号，也可以来探索某种存在的关系，但是实际生活中，缺少这种天然的对应关系，要找到本来存在的联系相对来说就变得困难了。 比如如果顺序是相对应的，我们可以找到一种线性关系，那么当打乱 ID 时，这种线性的 pattern 就变得模糊不清，甚至像是被藏起来了。
而且 Joiner 继续说到，实际上得到的实验数据总是离完美有那么一点点差距，比如对照实验要求除了感兴趣的因素外的其他应该完全相同，然而这是很难做到的。 比如关动物的笼子，放在上面的和放在下面的看到的景色是不一样的，本来，动物是要完全随机地被分配到笼子里，可实际上，离完全随机总是有一些差距。 因此，
A careful data analyst should not assume that the scale type of a variable is what it appears to be even when clear assurances are made about the data.
第八节 Stevens’s Categories Do NOT Describe Fixed Attributes of Data¶
这一节有两个例子说明我们可以将数据做不同的用途，在不同的例子中，显然数据的类型也是不同的，尽管它仍然是同一个数据。
The points of these examples, of course, is that the assertion, common to many traditional statistics texts, that “data values are nominal, ordinal, interval, or ratio” simplifies the matter so far as to be false. Scale type, as defined by Stevens, is not an attribute of the data, but rather depends upon the questions we intend to ask of the data and upon any additional information we may have.
Rozeboom (1966): If we can but find some interpretive significance in a statistic proscribed for scales of the type to which the scale in question has been deemed to belong, then that scale’s “type” therewith broadens to accomodate this newfound content.
第九节 Stevens’s Categories Are Insufficient to Describe Data Scales¶
本节给出其他一些例子，用于说明 Stevens’s Categories is NOT exhaustive.
比如一个 scale 可以是多维度的，比如横向的和纵向的，如下
横向的表示症状具体表现，纵向的表示症状总数，那么即使分别给数据的横向或纵向分类，结合起来已无法说明数据的类型。
第十节 Statistics Procedures Cannot Be Classified according to Stevens’s Criteria¶
比如一个 linear estimator, \(L=\sum a_{i}x_{i}\) ，如果我们取 \(a_{i} =\frac{1}{n}\) 那么 L 就是一个 Mean 平均值，这相当于说数据是 Interval 的。 可是如果我们 trim 一些（比 50% 只少一点）数据，那么 L 就是 Median 中位数，而这相当于说数据是 Ordinal 的。 于是，对于一般的情形，trim 的百分数介于 0-50 之间，这个 trimmed mean 好像是把数据两边的值当做是 ordinal 的，而把中间的当做 Interval 的。那么，
This estimator is thus on the continuum between Stevens’s ordinal and interval categories.
第十一节 Scale Types are NOT Precise Categories¶
Scale types 不是绝对的，不是非要完美地指出数据的类型，一旦做不到，就只能在跟宽松的 level 上指定一个类型。 比如，一个 Interval 数据，事实上来源于一个没校准的测量工具，那么显然，这些数据不是绝对的 Interval 数据，因为比价不同数据之间的差变得不那么有意义，因此，我们有可能只能讲该数据 demote 成 Ordinal 的，因为这些数据毕竟仍可以指出了不同值之间的大小。 然而，
when the errors are small relative to the measurements, we would sacrifice much of the information in the data if we are forced to “demote” them to ordinal scales.
Tukey 说，
An oversimplified and overpurified view of what measurements are like cannot be allowed to dictate how data is to be analyzed.
第十二节 Scales and Data Analysis¶
本节的叙述让我想起一句颇有政治意味的话语：“实践是检验真理的唯一标准”。
The scale type of data may be determined in part by the questions we ask of the data or the purposes for which we intend it.
Good data analysis rarely follows the formal paradigm of hypothesis testing.
A scientist must be open to any interesting pattern.
有一些东西，总是具有普遍的价值，请保持头脑的开发。
第十三节 Meaningfulness¶
本段更像是哲理性的讨论，作者认为 meaningfulness 的意义不是绝对的，数学家用某个常用的名词来表示某个严格的定义，并不重新定义那个名词本身。 这本身是个很好玩的事情，数学家在选择名词的时候，只是选取了这个名词的一小部分意义，而不是反过来由数学家来定义名词。
We must reason with respect to our imperfect description of the world. As Francis Bacon (1869) noted: “Truth emerges more readily from errors than from confusion.”
第十四节 A Role for Data Types¶
如果本文只是一味的反对 Data Types ，那么这篇文章价值也将打个折扣。 本段中肯地说明了 Data Types 的作用和意义，并再一次明确地指出 Stevens’s Typology 的问题所在。
The concept of scale is an important one, and Stevens’s terminology is often suitable. Indeed, much of the discussion of this article would be impossible without these concepts.
We must keep in mind, however, that scale types are not fundamental attributes of the data, but rather, derive from both how the data were measured and what we conclude from the data.
As Kuhn (1962) points out, “Discovery commences with the awareness of anomaly, i.e., with the recognition that nature has somehow violated the paradigm-induced expectations that govern normal science.”
第十五节 Conclusion¶
总结上述，不再赘言。
Footnotes
| [1] | A measurement scale is a rule (function) that associates a numerical or symbolic value with an attribute of an object. |
| [2] | This last problem, concerning the meaningfulness of empirical scalings and analyses based on them, continues to be a focus of statistical controversy. |
| [3] | \(Pr(|X-E(X)|\ge t) \le \dfrac{Var(X)}{t^2},\quad \forall t>0\) |


ABHISHEK SUNKARA MUDHIRAJ
I am currently pursuing my BTech at Vardhaman college of engineering. I`m a technology enthusiast and have an immense zeal to know about cool stuff and work on great projects.
PRASADH REDDY KAYITHI
I am very much interested in solving mathematical problems and logical puzzles. I would like to learn about various technologies and their working.
CHIRANJEEVI KARTHIK
I Love watching movies and tons of tv series. In my Free time, I try to experiment with various technologies and programming languages.


Copyright
Table of Contents
Index
Full Description
About the Author
Reviews
Colophon
Examples
Reader reviews
Errata
|
Learning Python
- Mark
Lutz
- David
Ascher
- Publisher: O'Reilly
First Edition April 1999
ISBN: 1-56592-464-9, 384 pages
Learning Python is an introduction to the increasingly popular Python programming language—an interpreted, interactive, object-oriented, and portable scripting language. This book thoroughly introduces the elements of Python: types, operators, statements, classes, functions, modules, and exceptions. It also demonstrates how to perform common programming tasks and write real applications.
|


What was once called "online life" is just "normal life" now. Life is funneled through our phones, laptops, and wearables: an incredibly detailed, annotated, timestamped diary that we unwittingly complete every minute of every day. But how permanent is your online trail?
If you wanted to go completely off the grid, how difficult would it be? It's incredibly difficult to completely disconnect from your online identity – or is it? In Part One of a look into what anonymity means in today’s society, Kathryn Lawrence explains what technology you need to use to disappear completely...
“Many, many years ago, so long ago that it’s a real stretch to find anyone else who can remember this, on the old Oprah show, she did a feature on individuals who had left society and, in the process, had eliminated every trace of themselves. She had like three or four guests up on stage, if I recall correctly, and they had all gone back and diligently destroyed every little bit of information previously known about them. Burning birth certificates and ID cards, canceling bank accounts. Stealing photos out of family member’s albums and destroying them. They had hired hackers to break into schools and erase their records.
"In fact, each of these persons had done such a bang-up job that all that was known about each of them was their social security numbers. (Although Oprah’s researchers were unable to say which social belonged to which person; these numbers were only known because of the noticeable gaps that were left in the government’s records.) On the program, these people sat in the dark; nameless and unsorted. No one knew who they were."
– excerpt from CLOSURE, by _why the lucky stiff
Uber has recently been embroiled in a series of scandals.
First, it was regarding sexual harassment in their offices, then fair pay for their workers on the road, followed by hidden programs designed to evade regulation – and most recently, their use of a rival's customer data. A recent New York Times profile of Uber’s founder revealed that they were using data mined by a web service called Unroll.me – a free service that was too good to be true.
Unroll.me combs through your email, finds services you’re subscribed to, and then unsubscribes from them for you, so that you can easily tidy up your digital presence. What they didn’t tell users (except in fine print in their terms of service) is that a lot of data about you found whilst combing through emails would then be available for sale.
For Uber, this was really useful: they could look at anonymised receipts from their rival ride-sharing business, Lyft. The users of Unroll.me didn’t find this so edifying, and a media uproar followed.
Whatever the moral quandary around data use, several other similar services exist, revealing a thriving market of people who want to delete their personal data wherever they can on the internet.
For instance: Deseat.me is an almost identical service to Unroll.me; Gmail Unsubscribe is another. Another, paid, service called DeleteMe will check the sites it deletes your data from periodically to be sure that your information hasn’t been recovered after "deletion".
People want to disappear; at least a little bit. But how?
"Nowadays we would label this kind of act as ‘information suicide’ or something very sophisticated, because people are much more aware of the importance of ones’ identities, but in those days we simply called it ‘jerktoasting’ and these people on the stage were just a few jerktoasters who got caught. We were fascinated by them, because no one of us had ever thought of deleting ourselves. It seemed futuristic to do so and it seemed to exhibit willful antipathy to do so, which, in a way, somehow seems quite futuristic as well.”
– excerpt from CLOSURE, by _why the lucky stiff
What does it take to commit “infosuicide”?
And where should you start if you want to begin to disappear? It might be easier to make a difference than you think. Here's how you could do it...
 So the first thing you would need to do is remove any and all banking information from the internet. That means no online banking, no PayPal, no Amazon or any other e-commerce websites, and no Netflix (if you pay for Netflix). A service like Cancel Wizard can actually go through some of these processes for you (for a fee).
No Social Media
This one seems fairly obvious, but any place where you have pictures of yourself can be found by reverse image search. Completely deleting Facebook, Twitter, Linkedin, and all of the others isn’t exactly made easy, but the data you create there is worth its weight in gold.
Sometimes it can be fun to dig into your old Myspace, Livejournal, or Xanga, but it’s also nice to know those old pictures or online diary entries won’t come back to haunt you. The services Just Delete Me and Account Killer rank sites by how difficult they are to remove your personal information from.
Even if you use a nickname that you think isn’t connected to your real identity in any way, it only takes one website’s lack of privacy to connect someone to every account where you use that same username.
Delete Yourself From Data Collection Sites
This CNET tutorial advises that you can look up your personal information on data brokers’ sites like Whitepages and Peoplefinder and individually request their deletion, but they also note that sometimes this requires filing actual paperwork.
This is where having a paid service like DeleteMe, who will do the web scouring for you, comes in handy. If you really want to do it all manually, a Reddit user compiled this list of the most commonly used background checking sites.
Contact Webmasters and Remove Your Domains
Google provides a handy list of web services they run that you can formally request having your information removed from, including the platforms Blogger/Blogspot, Google Drive, and YouTube. If you’ve ever owned a web domain, you should check the WhoIs databases to be sure that your phone number, address, email address, or any other personal info isn’t being saved and served to anyone.
via Mobile Beat
Blast the Cache
Even if your information has been removed from the current version of a website, the cache is king. Google lists several reasons on its troubleshooting page that they may deny your request to remove a cached version of a page, and services like the Internet Archive’s Wayback Machine retain cached versions of web pages for posterity and as a historical imperative.
There’s not much you can do about these, unless you go back to the previous step, look up the webmaster’s WhoIs data, and contact them directly with a request to purge your information from the cache.
and finally... Delete Your Email Address
Getting rid of all of these other services will most likely require having access to your email address, so this should be the last step. And possibly the hardest - although if you've seen the above process through this far, maybe it'll actually be an easy decision.
What will you do when you remove yourself from the Internet?
Discard your phone and read books or write letters instead? Eschew the VR headset and strike up conversation with strangers on public transport? Live like the Amish? Whittle sticks and slowly rock in a chair on your porch?
Can the modern person even exist off the internet grid entirely?
Next week, in Part Two, Kathryn finds out about life after you disappear completely from the web, and tells the fascinating story of a legendary developer who completely vanished from the internet – only to suddenly reappear years later.


Double-click setup.exe after you download and extract the file. The program will lead you through the complete installation process step by step.
Download 32-bit Setup File
Your computer is running the 32-bit version of Windows. Please download this file to install on your computer.
Download 64-bit Setup File
Your computer is running a 64-bit version of Windows. Please download this file to install on your computer.
If the "setup.exe" is not able to run on your computer, please click
HERE
。
Download and extract the file and then run apprun.sh to start the application.
Download 32-bit Compressed File
Your computer is running the 32-bit version of Windows. Please download this compressed file, and extract it on your computer.
Download 64-bit Compressed File
Your computer is running a 64-bit version of Windows. Please download this compressed file, and extract it on your computer.
Mac OS X
Version: 2.0.2, Release Date: 2017/5/18
Mountain Lion (10.8)
Mavericks (10.9)
Yosemite (10.10)
El Capitan (10.11)
Sierra (10.12)
After you download the file, open it and drag the icon to the folder "Applications".
Download
Your computer is running Mac. Please download this file to install on your computer.
Linux
Version: 2.0.2, Release Date: 2017/5/18
Ubuntu 10.04 or above
Fedora 21 or above
CentOS 5 or above
Debian 6 or above
Arch Linux 2016 or above
Elementary OS Luna (0.2) or above
openSUSE Leap 42.1 or above
Oracle Linux 5.5 or above
Red Hat Enterprise Linux 5.5 or above
SUSE Linux Enterprise Server 10 SP2 or above
Download and extract the file and then run apprun.sh to start the application.
We currently don't support Filelug on 32-bit version of Linux. Let us know if you need it.
Download 64-bit Compressed File
Your computer is running the 64-bit version of Linux. Please download this file, and extract it on your computer.


About type switch usage in Go
25 Dec 2014One of the features that I have been relying a lot in Go is the type switch. This feature is specially useful when using interfaces since it helps us avoid having to do type assertions all the time.
A couple of examples below.
Example #1
Let’s suppose that we have 3 types A
, B
& C
,
where each one of these types can be assigned a Name
:
package main
import (
"fmt"
"reflect"
)
type A struct { Name string }
type B struct { Name string }
type C struct { Name string }
And we put them inside of a slice which can contain interfaces
:
func main() {
a := &A{Name: "A"}
b := &B{Name: "B"}
c := &C{Name: "C"}
t := make([]interface{}, 0)
t = append(t, a)
t = append(t, b)
t = append(t, c)
Without using type switch
We would end up doing something like this:
fmt.Println("--- without type switching")
for _, thing := range t {
switch thing.(type) {
case *A:
fmt.Println(reflect.TypeOf(thing), "is of type A. Name is:", thing.(*A).Name)
case *B:
fmt.Println(reflect.TypeOf(thing), "is of type B. Name is:", thing.(*B).Name)
case *C:
fmt.Println(reflect.TypeOf(thing), "is of type C. Name is:", thing.(*C).Name)
}
}
Results
--- without type switching *main.A is of type A. Name is: A *main.B is of type B. Name is: B *main.C is of type C. Name is: C
Using a type switch
Makes things a little more bearable:
fmt.Println("--- type switching on the item")
for _, thing := range t {
switch o := thing.(type) {
case *A:
fmt.Println(reflect.TypeOf(o), "is of type A. Name is:", o.Name)
case *B:
fmt.Println(reflect.TypeOf(o), "is of type B. Name is:", o.Name)
case *C:
fmt.Println(reflect.TypeOf(o), "is of type C. Name is:", o.Name)
}
}
Results
--- type switching on the item *main.A is of type A. Name is: A *main.B is of type B. Name is: B *main.C is of type C. Name is: C
Example #2
Let’s see how far we can take it. Now, let’s suppose that we want to handle A and B the same way.
Using type switch
, it works too
Since we want to handle A
and B
the same way, we could think
that we could group them into the same case
, which would work:
fmt.Println("--- Grouping A and B: ")
for _, thing := range t {
switch o := thing.(type) {
case *A, *B:
fmt.Println(reflect.TypeOf(o), "is of type A or B.")
case *C:
fmt.Println(reflect.TypeOf(o), "is of type C.")
}
}
Results
*main.A is of type A or B. *main.B is of type A or B. *main.C is of type C.
Until it doesn’t
Let’s suppose that we want to inspect the value of the Name
field. Then it breaks:
for _, thing := range t {
switch o := thing.(type) {
case *A, *B:
fmt.Println(reflect.TypeOf(o), "is of type A or B. Name is:", o.Name)
case *C:
fmt.Println(reflect.TypeOf(o), "is of type C. Name is:", o.Name)
}
}
The above would throw the following error:
o.Name undefined (type interface {} has no field or method Name)
Back to interface
What happened here is that by trying to group A
, B
types, we ended up again
with an interface
, so we cannot rely on the first type switch anymore.
We could type switch once more time then:
fmt.Println("--- Double type switch all the way")
for _, thing := range t {
switch o := thing.(type) {
case *A, *B:
switch oo := o.(type) {
case *A:
fmt.Println(reflect.TypeOf(o), "is of type A or B. Name is:", oo.Name)
case *B:
fmt.Println(reflect.TypeOf(o), "is of type A or B. Name is:", oo.Name)
}
case *C:
fmt.Println(reflect.TypeOf(o), "is of type C. Name is:", o.Name)
}
}
Results
--- Double type switch all the way
*main.A is of type A or B. Name is: A
*main.B is of type A or B. Name is: B
*main.C is of type C. Name is: C
…which looks a bit messy. A more straightforward way would be to flinch away our desire to make things “DRY”, still rely on the first type switch and just repeat more code:
fmt.Println("--- The Go Way™")
for _, thing := range t {
switch o := thing.(type) {
case *A:
fmt.Println(reflect.TypeOf(o), "is of type A or B. Name is:", o.Name)
case *B:
fmt.Println(reflect.TypeOf(o), "is of type A or B. Name is:", o.Name)
case *C:
fmt.Println(reflect.TypeOf(o), "is of type C. Name is:", o.Name)
}
}
…which results in:
--- The Go Way™ *main.A is of type A or B. Name is: A *main.B is of type A or B. Name is: B *main.C is of type C. Name is: C
Progress so far
So which one of the approaches is better?
I would say that probably the one with the
multiple case statements where the same line is repeated, since when
we type switch and have a case
statement with one more type,
we end up once again with an interface
, and we need yet another type switch
for it that generates more code which more or less says the
same thing, so it seems that it is about as DRY as it could get
for now using only type switch
.
Link to the Go playground with the example
To solve the grouping problem, there is something else that we can
try besides only using the type switch
, which is using interface
types.
Example #3
Another alternative would be to use a Nameable
interface when creating the slice.
This means first having to declare something like this:
type Nameable interface {
GetName() string
}
type BasicAttrs struct {
Name string
}
// Code generation could help with this...
type A struct { BasicAttrs }
func (o *A) GetName() string { return o.Name }
type B struct { BasicAttrs }
func (o *B) GetName() string { return o.Name }
type C struct { BasicAttrs }
func (o *C) GetName() string { return o.Name }
So that we can later on use it as follows:
func main() {
a := &A{BasicAttrs:BasicAttrs { Name: "A" }}
b := &B{BasicAttrs:BasicAttrs { Name: "B" }}
c := &C{BasicAttrs:BasicAttrs { Name: "C" }}
t := make([]Nameable, 0)
t = append(t, a)
t = append(t, b)
t = append(t, c)
fmt.Println("--- The correct Go way?")
for _, thing := range t {
switch o := thing.(type) {
case *A, *B:
fmt.Println(reflect.TypeOf(o), "is of type A or B. Name is:", o.GetName())
case *C:
fmt.Println(reflect.TypeOf(o), "is of type C. Name is:", o.GetName())
}
}
}
Results
--- The correct Go way? *main.A is of type A or B. Name is: A *main.B is of type A or B. Name is: B *main.C is of type C. Name is: C
Is this better?
I think so. Even though the implementation is a bit more verbose, the last example using a type interface
might be the way to go in case we face the grouping issue from the raw interface.


|
|||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
| Interface Summary | |
|---|---|
| Spillable | |
| Spillable.SpillListener | |
| Spillable.SpillStrategy | |
| TupleCollectionFactory<Config> | Interface TupleCollectionFactory allows developers to plugin alternative implementations of a "tuple collection" used to back in memory "join" and "co-group" operations. |
| TupleMapFactory<Config> | Interface TupleMapFactory allows developers to plugin alternative implementations of a "tuple map" used to back in memory "join" and "co-group" operations. |
| Class Summary | |
|---|---|
| SpillableProps | Class SpillableProps is a fluent interface for building properties to be passed to a
FlowConnector before creating new Flow instances. |
| SpillableTupleList | Class SpillableTupleList is a simple durable Collection that can spill its contents to disk when the
threshold is met. |
| SpillableTupleMap | SpillableTupleMap is a HashMap that will allow for multiple values per key, and if the number of values for a given
key reach a specific threshold, they will be spilled to disk using a SpillableTupleList instance. |
|
|||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |


--- layout: page title: Contact ░▒▓█│【Walkman】│█▓▒░ --- Preferred contact method: Telegram
All trademarks are property of their respective owners in the US and other countries. See this.


TiTle: Plain HTML entry Date: 2018-03-31 00:58:20-07:00 UUID: 09794e21-bc14-4f7e-9a96-537656f0c3d4 Entry-ID: 309
This is an entry made of plain HTML.


Small intro on what we need.
The “Hello world” of IoT.
Control hardware from the browser.
Johnny-Five is the JavaScript Robotics & IoT Platform.
An easy way for controlling hardware inspired by the web.
const { RaspiIO } = require('raspi-io');
const five = require('johnny-five');
const board = new five.Board({
io: new RaspiIO()
});
board.on('ready', () => {
const led = new five.Led('P1-12');
led.blink();
});


Vorta is powering one of the most fleksible and easy to use supply chain management tools on the market. Regardless of the size of your company we provide efficient and effordable tool that allows unique control of SCM chain. Vorta's meticulously designed user experience provides realtime insight in your business as well as detailed tracking of orders and shipment process. Vorta has been built in collaboration with SCM experts and as such has taken unique approach for problem solving in world of SCM.
We believe that lack of good software for SCM is rooted in methadology, and not so much in software. Archaic approaches to these complex problems are omnipresent in the market and are instantly recognizible in way software is designed and organized. We obsessibely seek out elegant, composable abstractions which allow robust, adaptible solutions which are easy to undesrstand and follow. Because we eliminate needless complexity and extraneous details, our clients are able to focus on minimal set of information and thus do their job better.
Vorta is an always-improving toolchain that gains new features every month. Our team is constantly working with our clients to face new challanges and provide elegant solutions which are in aligned with current Vorta structure. Our team includes quality and software engineers as well as SCM experts. Road is long and with every new step we take, we are constantly thinking on steps we took before and steps we will take in future. Some of our steps so far.
Adding new SKU(s) to system does not have to complicated process, and with Vorta it is not. In minutes user are able to add new products, define their characteristcs, set pricing and start the ordering process. Vorta allows planing of complex customer shipments. You need to prepare shipment and aggregate products from multiple inventories. We can handle that with suprising simplcity.
Has the order been shipped yet? Have the customs cleared the shipment? Has customer been notified? Organization of this scale is always complicated endevour but it does not have to be. Vorta allows all participants access to the system and based on their permission access to needed information.
Planing shipments is complicated endevour. Many goods have to be moved from internal locations before they can be sent to customers. Vorta handles this part of the process with ease. Plan your shipments in a such way where software will recognize future internal shipments and allow you to plan future customer shipments. Tracking on all the goods movements along the way.
With Vorta you are able to track your product from manufacuring to end customer. With that information you can focus on which steps in your supply chain are having problems and have enough information to address them. Having issues with lost products and unexpected claims? Each product is uniquly tracked trough the system and detailed information is available in real-time.
Since Vorta is controling all aspects of SCM of your company you are able to get details about each step of this way. Sales, factory availability, claim information etc. We as the company that recognizes importance of this type of information and are always ready to improve and add new reporting options.
How many diffrent softwares are being used to organize logistic chain? How do you track shipments, orders, prices, claims, invoices, customs documents and list goes on.
Using supply chain management can be needlessly complicated. That is for a good reason, many moving parts are hard to present to the user in a human readable way. That is why Vorta takes different approach. We avoid unnecessary complications that come with detailed customization of the software and instead we focus on optimal methodology for running supply chain management. This does not mean that the user cannot customize their experience, just the extent of customization is lowered so that user experience provide out of the box is best that it can be. By focusing on what is important we are able to streamline the process, providing a friendly interface that reduces possible mistakes with each step.
“Design must be functional and functionality must be translated into visual aesthetics, without any reliance on gimmicks that have to be explained. ” — Ferdinand A. Porsche
“Creativity is just connecting things. When you ask creative people how they did something, they feel a little guilty because they didn’t really do it, they just saw something. It seemed obvious to them after a while. ”— Steve Jobs
“I think design would be better if designers were much more skeptical about its applications. If you believe in the potency of your craft, where you choose to dole it out is not something to take lightly. ”— Frank Chimero


Landing Page
Special Projects
This story is part of a series of specially designed stories that represents some of the best journalism The Post has to offer. Check out the rest of the special projects here.
Illustration by Megan Knapp
Honey from the Hive
Smoked to Perfection
Tip of the Iceberg
Storytelling Through the Arts
Resilience
Enduring Connections
Chords and Camaraderie
Haunting at the Opera
Preserving the Past
Going Beyond the Bubble
From the Editor's Desk
Landing Page
This story is part of a series of specially designed stories that represents some of the best journalism The Post has to offer. Check out the rest of the special projects here.


Food Tracker
Date Item was Consumed:
What you had to eat/drink:
Category
Drink
Snack
Breakfast
Lunch
Dinner
Dessert
Expiration Date:
Serving Size/Portion:
Submit
Date Consumed
Food Name
Category
Expiration Date
Serving Size


"{{quotes.quote}}" By: {{quotes.author}} Posted by: {{quotes.name}} Posted on: {{quotes.completeDate}}


Daniela Haidar's Portfolio
About Myself
I'm a junior at Brown University pursuing a double concentration in Computer Science (focus on AI/ML and Data Science) and Economics. I'm from Sao Paulo, Brazil, but have been living in Providence, Rhode Island for the past three years.
Type me a message and I'll perform sentiment analysis on it!
Experience
| Spring 2021 | Undergraduate Teaching Assistant @ Brown University | TA for the course 'CSCI 1951a - Data Science'. I revise and grade assignments, hold hours to help students understand the material and assist them in debugging their programs. |
| Since Fall 2019 | Undergraduate Research Assistant @ Brown University's AI Lab |
| Under the guidance of Professor Carsten Eickhoff, I work with machine learning techniques and neural network models in order to improve electrical-stimulation treatments. | |
| Summer 2020 | Data Science Intern @ Vioo |
| Defined OKR metrics for the data team; assisted in the selection of new members; restructured and cleaned our user database; designed PowerBi dashboards to help different teams keep track of company growth and engagement. | |
| Summer 2019 | Summer Analyst @ Banco Plural |
| Investment Banking: Worked on valuations and pitches. Business Intelligence: Collected and analyzed data, automated excel files using VBA. Trading: Rotation on renting, futures, fixed income, options and risk. |
SPS Experience
This Spring 2021, I'm participating in an invite-only Google program called Software Product Sprint. This portfolio is actually part of it! During this first week we were tasked to create the client side of it. I can't wait to see what my team will be working on the next few weeks.
Quote Generator
Click here to get a random quote from my favorite TV show, Gilmore Girls:


|
|||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
See:
Description
| Interface Summary | |
|---|---|
| AccumulableParam<R,T> | Helper object defining how to accumulate values of a particular type. |
| AccumulatorParam<T> | A simpler version of AccumulableParam where the only data type you can add
in is the same type as the accumulated value. |
| CleanupTask | Classes that represent cleaning tasks. |
| FutureAction<T> | A future for the result of an action to support cancellation. |
| Logging | :: DeveloperApi :: Utility trait for classes that want to log data. |
| Partition | An identifier for a partition in an RDD. |
| SparkJobInfo | Exposes information about Spark Jobs. |
| SparkStageInfo | Exposes information about Spark Stages. |
| TaskEndReason | :: DeveloperApi :: Various possible reasons why a task ended. |
| TaskFailedReason | :: DeveloperApi :: Various possible reasons why a task failed. |
| Class Summary | |
|---|---|
| Accumulable<R,T> | A data type that can be accumulated, ie has an commutative and associative "add" operation,
but where the result type, R , may be different from the element type being added, T . |
| Accumulator<T> | A simpler value of Accumulable where the result type being accumulated is the same
as the types of elements being merged, i.e. |
| AccumulatorParam.DoubleAccumulatorParam$ | |
| AccumulatorParam.FloatAccumulatorParam$ | |
| AccumulatorParam.IntAccumulatorParam$ | |
| AccumulatorParam.LongAccumulatorParam$ | |
| Aggregator<K,V,C> | :: DeveloperApi :: A set of functions used to aggregate data. |
| CleanAccum | |
| CleanBroadcast | |
| CleanCheckpoint | |
| CleanRDD | |
| CleanShuffle | |
| CleanupTaskWeakReference | A WeakReference associated with a CleanupTask. |
| ComplexFutureAction<T> | A FutureAction for actions that could trigger multiple Spark jobs. |
| Dependency<T> | :: DeveloperApi :: Base class for dependencies. |
| ExceptionFailure | :: DeveloperApi :: Task failed due to a runtime exception. |
| ExecutorLostFailure | :: DeveloperApi :: The task failed because the executor that it was running on was lost. |
| FetchFailed | :: DeveloperApi :: Task failed to fetch shuffle data from a remote node. |
| HashPartitioner | A Partitioner that implements hash-based partitioning using
Java's Object.hashCode . |
| InterruptibleIterator<T> | :: DeveloperApi :: An iterator that wraps around an existing iterator to provide task killing functionality. |
| JavaSparkListener | Java clients should extend this class instead of implementing SparkListener directly. |
| NarrowDependency<T> | :: DeveloperApi :: Base class for dependencies where each partition of the child RDD depends on a small number of partitions of the parent RDD. |
| OneToOneDependency<T> | :: DeveloperApi :: Represents a one-to-one dependency between partitions of the parent and child RDDs. |
| Partitioner | An object that defines how the elements in a key-value pair RDD are partitioned by key. |
| RangeDependency<T> | :: DeveloperApi :: Represents a one-to-one dependency between ranges of partitions in the parent and child RDDs. |
| RangePartitioner<K,V> | A Partitioner that partitions sortable records by range into roughly
equal ranges. |
| Resubmitted | :: DeveloperApi ::
A ShuffleMapTask that completed successfully earlier, but we
lost the executor before the stage completed. |
| SerializableWritable<T extends Writable> | |
| ShuffleDependency<K,V,C> | :: DeveloperApi :: Represents a dependency on the output of a shuffle stage. |
| SimpleFutureAction<T> | A FutureAction holding the result of an action that triggers a single job. |
| SparkConf | Configuration for a Spark application. |
| SparkContext | Main entry point for Spark functionality. |
| SparkContext.DoubleAccumulatorParam$ | |
| SparkContext.FloatAccumulatorParam$ | |
| SparkContext.IntAccumulatorParam$ | |
| SparkContext.LongAccumulatorParam$ | |
| SparkEnv | :: DeveloperApi :: Holds all the runtime environment objects for a running Spark instance (either master or worker), including the serializer, Akka actor system, block manager, map output tracker, etc. |
| SparkFiles | Resolves paths to files added through SparkContext.addFile() . |
| SparkFirehoseListener | Class that allows users to receive all SparkListener events. |
| SparkJobInfoImpl | |
| SparkStageInfoImpl | |
| SparkStatusTracker | Low-level status reporting APIs for monitoring job and stage progress. |
| Success | :: DeveloperApi :: Task succeeded. |
| TaskCommitDenied | :: DeveloperApi :: Task requested the driver to commit, but was denied. |
| TaskContext | Contextual information about a task which can be read or mutated during execution. |
| TaskKilled | :: DeveloperApi :: Task was killed intentionally and needs to be rescheduled. |
| TaskResultLost | :: DeveloperApi :: The task finished successfully, but the result was lost from the executor's block manager before it was fetched. |
| UnknownReason | :: DeveloperApi :: We don't know why the task ended -- for example, because of a ClassNotFound exception when deserializing the task result. |
| Enum Summary | |
|---|---|
| JobExecutionStatus |
| Exception Summary | |
|---|---|
| SparkException | |
| TaskKilledException | :: DeveloperApi :: Exception thrown when a task is explicitly killed (i.e., task failure is expected). |
Core Spark classes in Scala. A few classes here, such as Accumulator
and StorageLevel
, are also used in Java, but the
org.apache.spark.api.java
package contains the main Java API.
|
|||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |


Biome is a 3D-roguelike prototype made in C# with Unity, done as a school project over a semester. I worked on the procedural terrain and objects generation. On this page you will find some details on this part.
You can check the source code here.
Introduction
You can take a look at this presentation video realised at the end of the project.
We were a team of five students on this project. We divided the work in three parts : the gameplay and enemies, which was done by two of us, the user interface and the project lead, taken by the student who had the idea for this project, and the environment generation, which we were two to do.
The objectives were to dispose of a tool that would enable game designers to design maps for the game Biome. We decided to keep it as configurable as we could. However, some decisions were made and fixed. We wanted the world to be composed of several ring shaped regions called biomes.
The objectives were :- have a big map
- have configurable biome numbers
- have configurable relief for each biome
- enable dynamic relief modification
- lessen the impact of the generation on the framerate
Coordinates system and initial generation
Since the world was going to be circular, I thought it would be interesting to use a hexagonal shaped grid instead of a traditional square grid, in order to smooth the generation. Lots of thanks to Amit Patel and his Hexagonal grid reference which made this a lot easier.
We then decided to cut the terrain in tiles. Those tiles would have configurable sizes, both concerning the hexagons size and the tile radius, as you can see in the figure. This makes it possible to change those parameters to generate a smaller or bigger map with different costs.
During the development, when facing a bug we often tried several tile radii in order to identify it, but we usually sticked at the value 17, except one of us who had difficulties running it on his computer, and used a smaller value.
You might see it on the figure, the hexagons are not exactly regular. In order to ease some computations, I made them a bit higher. Thinking about it some time later, I reckon this might have caused some problems we faced during the development.
{% include file_name=biome/one_tile.html %}
{% include file_name=biome/first_generation.html %}
We then assembled those tiles in order to create the terrain, whose starting area is generated in the following order :
- The center tile (on which the player begins)
- All tiles of the first ring of tiles, turning counter-clockwise
- Then the next ring, until a target ring is reached
The number of rings generated for the starting area is configurable.
The relief of the terrain is determined through a Perlin Noise. Each hexagon has a height, which is computed through mixing Perlin Noises.
Using Perlin Noise makes points that are spatially close have similar heights. This was perfect, since we wanted a terrain with moderate local height variations.
Each corner of the hexagon is then attributed the mean of the three surrounding hexagons.
You can see an example on the figure (the values here are arbitrary and were not computed from a real Perlin Noise).
Since we only need the hexagon height value of the neighbors before creating the 3D model of one tile, we first generate all neighbor tile hexagon heights, then calculate each points height for the 3D model. I will describe this a bit more when talking about object generation.
During the game, when the player moves, the position is tracked in order to load only the tiles that are close to this position. When the player goes to a place where tiles were not generated, those are generated as the games asks to load them. With this system, we were able to have a big map, that is only loaded locally and that does not need too much time to build before the game starts.
Object Generation
Once we had a terrain, we wanted to place some objects on it. We divided objects into two categories : small objects (trees, bushes, rocks, columns, etc) that can be placed quite anywhere, and big objects (buildings, bigger rocks, ruins, etc) that need a flat terrain underneath.
Concerning big objects, we thought it would be quite difficult to look for a flat space on the map, so we decided we would flatten the terrain before placing the object. We thus placed the object generation step between the hexagon height attribution, and the 3D model construction, in order to be able to modify existing height before creating the model. However, one object could be placed near the border of a tile, and thus need to alter the neighbor tiles height data, and placing space occupation indicators on them (we used it to prevent objects from spawning too close to each other).
IIn same idea, one tile could place an object close to its neighbour located on a ring closer to the center during the initial generation. The generation order was thus altered as such :
- Attribute height to the center tile (which can be considered as ring zero)
- Attribute height to the first ring
- Attribute object location on the center tile
- Attribute height to the next ring
- Attribute object location of the current ring
- Compute 3D model of previous ring
- Switch to the next ring and repeat from step 4
Each step for each ring is still done on every tile, as shown before. With this method, we leave some rings with only height attributions, that will have their objects and 3D model generated as the player comes close.
See how there always will be a two tiles thick crown partially generated around the fully generated area.
{% include file_name=biome/object_generation.html %}
With those modifications, we made it possible to implement dynamic modification of the terrain, but we did not use it. A great application would be to adapt the terrain depending on how the player behaves, and how difficult the game is, in a similar way as the Gameplay/Ennemies team did for enemies.
Other stuff
At the end of the project, we had some documents to create in order to present our project. There was an oral presentation (and its support), the presentation video, a poster, an image which represents the project, that you can see at the top of this page, a design document, a few situational short descriptions, and a build of the project (google drive links : windows, linux).
I made the video : we all captured clips of scenes we thought represented well our work on this project. One of us made the music. Then I assembled the clips and the music in a video, using Blender. I also made a part of the image : I assembled the screens a friend took of generated terrain (from an orthographic side view), assembled them, cleared artifacts due to the orthographic view, and smoothed the transitions between terrains. My firend then added the hexagonal mosaic effect and the texts.
You can see another member's own page for this project here.


My name is Tynan Drake and I am studying Interactive Digital Media at Drexel University in Philadelphia. My studies are focused on UI / UX design, but I am also heavily involved in graphic design. I am currently growing a personal graphic-design based Instagram page that has grown to over two thousand followers in the past year.


Drag the orange dot to NUMBER. The distance between adjacent tick marks is 1.
init({
range: [ [LOWER_BOUND - 1, UPPER_BOUND + 1], [-1, 1] ]
});
line( [ LOWER_BOUND, 0 ], [ UPPER_BOUND, 0 ] );
for ( var x = LOWER_BOUND; x <= UPPER_BOUND; x++ ) {
line( [ x, -0.2 ], [ x, 0.2 ] );
}
style({ stroke: "#6495ED", strokeWidth: 3.5 });
line( [ 0, -0.2], [0, 0.2]);
label( [ 0, -0.53 ], "0", "center", { color: "#6495ED" });
addMouseLayer();
this.movablePoint = addMovablePoint({ constraints: { constrainY: true }, snapX: 0.25 });
movablePoint.onMove = function( x, y ) {
if (x < LOWER_BOUND || UPPER_BOUND < x) {
return false; // don't allow the point to move past the bounds
}
jQuery("#solutionarea input").val( x );
};
We know where 0 is on the number line because it is labeled.
Numbers to the left are smaller, and numbers to the right are bigger.
Numbers smaller than 0 are negative, and numbers bigger than 0 are positive.
style({ stroke: "#6495ED", fill: "#6495ED", strokeWidth: 3.5, arrows: "->" });
line( [ 0, 0 ], [ NUMBER, 0 ] );
movablePoint.visibleShape.toFront();
The orange dot should be plural( abs( NUMBER ), "position") to the leftright of 0.
label( [ NUMBER, -0.53 ], NUMBER, "center", { color: "#FFA500" });
movablePoint.moveTo( NUMBER, 0 );
The orange number shows where NUMBER is on the number line.


We disrupt Coding by re-inventing Where and Why you will be coding Instead of How and What you’ll be coding
Google Custom Search Engine