@bel, left a note

@m_goldberg, it's open now.

@MichaelHale But the whisker is not supposed to switch around :-)

The difference becomes visible when you use it without outliers:

Manipulate[GraphicsColumn[
  {BoxWhiskerChart[{0.5, max, 1.0, 1.5, 2.5}],
   BoxWhiskerChart[{0.5, max, 1.0, 1.5, 2.5}, {{"Outliers"}}]
   }], {{max, 9.5}, 0, 10}]

@halirutan Take a look at the code I posted (from the docs) and see if that helps you

@MichaelHale But can it be that they restrict the length..

@belisarius wait

@belisarius Ah, right. That's what I read a second ago in the wiki page.

@halirutan a new "outlier" appears

So they restrict the lenght of the whisker when it becomes too large (in this case, the moment when they draw outliers

yep

@belisarius That looks ugly

@belisarius I can almost smell the questions of the reviewers :-)

well, at least one can understand what is happening :)

@halirutan How true!

@belisarius They don't understand what a p-value really means, how are they supposed to cope with this..

@halirutan Ref [1]

[1] Private bug report from WRI

ha!

What to do on 9-hour flight? Play with Mma. Otherwise nice, but usually I run into branches of mathematics I don't know well during that time, and experiments become a bit desperate... but it's still more interesting that doing something else (including attempts of to sleep).

@kirma Sometimes an audio book is a nice flight compnion

In nine hours you can "read" War and Peace

I feel I go crazy if I don't have something to think about on the flight. Maybe only more passive alternative I find attractive is watching QI (quite recommendable series in my opinion), but otherwise, tinkering with Mma feels like the best option.

Is there any option or builtin way to make something like a ListStreamPlot without information about the direction of vectors? I.e. I have an orientation and a magnitude for each vector, but I cannot distinguish v from -v.

Anyone know how to query possible warnings or error messages defined for a built-in function? List, for example?

@Szabolcs You means something like

ListStreamPlot[data, StreamScale -> None]

@dionys, most of the messages are usually associated with General; Messages[General] should return a nice pile.

Otherwise, I suppose you could modify the function here to search the message name instead of the message text.

@Guesswhoitis. Thanks. Looks like just what I need.

@halirutan No exactly. It's not about how it's displayed, but how the streams are computed. Currently they use the direction of the vectors, but I do not have that. Imagine taking half of the vectors randomly and flipping them (i.e. multiply by -1). I have data similar to that.

@Szabolcs Ahh, I see. Let me think about this.

Murrrnin

@JukEboX This is not proper English. It should be "Good Mourning" :-)

@Szabolcs I'm pretty sure there is no built-in way for doing this because all those functions rely on the interpolation of the vector field. Depending on how dense your vector-field is, you could probably correct the data and then feed it to ListStreamPlot or you keep it simple and draw one vector-line per vector without arrow head.

Btw, randomly flipping directions on an otherwise smooth field and feeding it to ListStreamPlot (just for the sake of seeing how WRI handles it) will crash my Kernel or eat up 32 GB of RAM and crash Kernel and FE. Depending on the mood my Mathematica is in.

@Szabolcs About correcting your vf: I'll first start with a simple "flood fill" like algorithm that flips directions of neighboring vectors if they would be more similar after flipping.

I wonder why they don't auto-convert two keyboard characters to one special character for [[ and <| like they do for ->. I guess the parsing would be slightly more complicated to detect a ]] properly, but it'd be nice.

@MichaelHale It's not possible to know that a one character ]] would be correct to insert without parsing the whole expression.

At least you need to trace back until the opening [[.

@halirutan Yes, that's why I said ]] would be more complicated, but it'd still be nice.

@halirutan It's surely no more complicated than what they already keep track of for doing the auto-indentation.

@MichaelHale One of the biggest problems with the front-end is that is has to parse the cell over and over again on every key-stroke.

This is a technique that non of today's IDE could use.

@halirutan I haven't had many cells that are larger than a page. I have noticed the annoying effect of opening a new quote inside a cell and the effects are more drastic than other IDEs.

I talked about this with John Fultz some time ago. It's hard to get rid of such things in big system like Mathematica.

@MichaelHale Yep, but there are users that have a different programming style which sometimes has very large cells.

I use RStudio a lot at work. I just opened a quote in a large file there and it recolored everything. The auto-indentation can be annoying when you delete something for example and suddenly the cursor jumps to the previous line and the other lines reposition.

@MichaelHale I don't like the auto-indentation either. I would rather prefer to make all indents myself, but there are a lot of users that love this feature.

@halirutan But WR definitely still seems focused on encouraging small scripts instead of large applications. Like, all of their blog posts are focused on script type things. If you read a Microsoft developer blog though they often reference very large sample projects.

@halirutan I'm on the fence I suppose. Sometimes I like it, sometimes I don't. Haven't paid much attention to the exact behavior of it.

@MichaelHale It's because 94.6% of the users don't develop large package code. Their daily work consists of notebooks with many cells and to run something they usually evaluate many cells to load definitions.

@halirutan Yeah. I mostly don't like auto-indent when I'm typing inside existing code. When I'm typing at the end of a code block I like it more. But when typing inside existing code often the typing cursor will jump around unexpectedly, and that's frustrating.

Sometimes I have a feeling that it is kind of a weird win-win situation: WRI seems to want to have a full-fledged programming language but basically they don't. Most of their users are likewise. Therefore, they give their big language a nice name but most of the time they encourage things like "twitter a code" or demonstrations that are rather short.

Another initial test of designing games with association automata:

entities = <|
   "crab town" -> <|"residents" -> 20, "damage level" -> 0|>,
   "fisherman" -> <|"behavior" -> "fishing"|>
   |>;

rules = {
   {"fisherman", "behavior", Switch[#,
      "fishing", {"reeling",
       If[#2["crab town", "residents"] > 0,
        RandomChoice[{1, 3} -> {"caught", "empty"}], "empty"]},
      {"reeling", _}, {"waiting", 2},
      {"waiting", _?Positive}, {"waiting", #[[2]] - 1},
      {"waiting", 0}, "casting",
      "casting", "fishing"] &},
   {"crab town", "residents",

Then

state = entities; Grid[{{Button["Step",
    state = Fold[
        ReplacePart[#, {#2@"entity", #2@"property"} -> #2[
             "rule"][#[#2@"entity"][#2@
              "property"], #]] &, #, <|"entity" -> #,
           "property" -> #2, "rule" -> #3|> & @@@ rules] &@state],
   Dynamic@Column@Normal@state}}, Frame -> All,
 Alignment -> {Center, Center}]