@halirutan I think so. If things like variable bindings in lexical scope can be inspected and manipulated by rules, this means that they can be broken. And that's exactly what happens. It is not clear to me whether it is possible to come up with a design which would reconcile lexical scoping and rules / pattern-matching, keeping the scoping fully robust.

@halirutan Presumably, Daniel Lichtblau did this in his implementation of the "StrictLexicalScoping" option, but I don't know if that covers all possible cases. OTOH, black boxes are very much against Mathematica's core principles. It may be that Mathematica needs some additional pattern-matching primitive, or attribute, which would make certain expressions or symbols be treated as atomic for the purposes of pattern-matching, unless overridden explicitly.

@LeonidShifrin Let's assume one wants to know whether there is some theory behind this, were would you start to read? I mean, most of the stuff like currying, anonymous functions, map, fold, etc is described in literature in detail.

@halirutan Wow, didn't expect to see you here at this time!

@LeonidShifrin Expect the unexpected :-)

@halirutan Yep :)

@LeonidShifrin I'm looking at all the extension points of IDEA to see what can be done next.

@halirutan Re: where to start - I really don't know. Mathematica's pattern-matching is different from pattern-matching described in the literature for other functional languages.

@LeonidShifrin I can give another example:

I was (I don't know why) looking through the bugs of Mathics and one issue caught my eye. It was about the sorting of definitions by generality of the used patterns.

@halirutan As a part of my very slow progress on FE - based IDE, I wrote a static code analyzer to be able to track dependencies statically and jump across projects. I think this would be a generally useful functionality, also in your case

@halirutan Re: sorting by generality - I'd think that this particular issue is rather hopeless.

@LeonidShifrin We have a very prominent question about this here which wasn't answered yet and I think this is a pretty though topic.

@halirutan In the sense that one would have to know the precise details of the algorithm currently employed to do that, and that does change from version to version.

@LeonidShifrin So there is no solid theory behind it?

@halirutan Besides, it may well be that this algorithm also uses some run-time information, in which case it might be very hard to do this analysis statically.

@LeonidShifrin But once sorted, the order of the DownValues is not changed anymore and you sometimes have to fix it yourself. Or do you mean dynamically when I evaluate the SetDelayed?

@halirutan My guess is that there isn't a solid theory. Even for patterns not involving calls to the main evaluator, Mathematica is not always able to decide on the relative generality of them. I think that in general, this might be a very tough problem.

@halirutan Yes, the rules are reordered by the system when SetDelayed is evaluated

@LeonidShifrin Hmm, I thought there might be literature one can study. On the first topic of black boxes are very much against Mathematica's core principles....:

@halirutan And at that moment, who knows what the reordering algorithm is using.

But there are some black boxes (or places where rules are broken). For instance that you cannot Block certain symbols or make changes on them.

@halirutan My impression is that the pattern-macther in Mathematica can not be fully described by just static code analysis, and embeds also certain algorithms the outcome of which can only be decided when we have the actual data.

So why wasn't something like this used to implement proper scoping.

@halirutan Being unable to block some symbols or change their definitions is not the same as not obeying the general rule mechanics. But you are right, for example there are objects which are not described fully by their FullForm, in the sense that you can't use the FullForm in place of the objects (graphs for example). And we have discussed already, that those design decisions seem quite questionable to many of us here on SE.

@halirutan I certainly am not fond of that idea, and I remember WReach also expressing similar feelings (perhaps Szabolcs too, not quite sure about him).

@LeonidShifrin Correct, because (at least I) you get used to have everything laid out by FullForm and when this is changing you might run into things you haven't expected (replacing things in such special objects for instance).

On the other hand, it is quite important to keep for instance the speed of Image's reasonable, so fast under-the-hood data is necessary.

@halirutan But I agree, that some form of encapsulation would be needed to implement scoping properly. I just think that this should be something which can be defined and overridden on per-symbol or per-expression basis, and by default be atomic for the purposes of pattern-matching - that's how I'd do that, at least.

@halirutan Agree on performance. There are only two ways out: either implement properly the support for (immutable) persistent (purely functional) data structures in the language (like Haskell or OCaml do), or break the current model Mathematica uses. The second way is simpler, and apparently was chosen for Graphs and perhaps other objects too.

@halirutan All right, the real person to ask about this stuff has arrived!

@LeonidShifrin In my opinion, here it is quite noticeable that Wolfram needed a theoretical computer scientist in the early days. Someone like Simon Peyton Jones.

@halirutan +1

Hi @WReach! I wonder whether you were pinged or found this conversation by accident. Either way, would be cool if you could share your thoughts.

@halirutan Totally agree.

@LeonidShifrin I guess someone hacked the NSA traffic filters for his purpose.

@LeonidShifrin It is just chance. I just got home and started reading the transcript. I've sometimes wondered whether object-like items like Graphs could have a dual representation. A high-performance object and a full-form. The tricky bit would be propagating changes to the full-form back to the object.

Maybe there could be a new type of head for that purpose.

@WReach I thought about that too, perhaps in less clearly formulated way. I wonder whether some limited form of mutability like OCaml-style references could be used for that purpose.

Hello

@Rojo Hola

@LeonidShifrin привет (?)

@WReach Keeping the two representations synchronous is probably what will break the neck. You have to ensure that both versions are up-to-date, otherwise this might lead to unexpected behavior.

@Rojo Yep, that's right )

You are talking about something like packed arrays for other structures?

Meaning, you see a full form, it's not an atom, but internally it kind of is an atom?

Does someone remember what is was like back in the days of 5.2 when a Graphic was Postscript?

@WReach Or would it be necessary to only use persistent purely functional data structures, and then, can they provide acceptable performance in all cases of interest.

@Rojo Yes, something like that. A built-in evaluation rule that would convert the symbolic form to the fast form as needed internally. It would rely upon the immutability of the source expression, something that we (mostly) get for free.

@Rojo Yes, things like Graph, which look like they are non-atomic and stateless, while being atomic and stateful

@halirutan I certainly remember 5.2, but not those parts, I never was much into graphics.

@Rojo Sorry, I misinterpreted the question.

I just made a mess in the kitchen because of reading the transcript and forgetting the noodles, rgr

@halirutan Yes, but depending upon the internal design of the evaluator, it feels like it might be possible. I'll go even further: I'd like a "NativeValues" analog to "UpValues" and "DownValues" that would invoke some C++ or Java API to let us mere users to participate in this space.

@WReach It might actually work, when one uses the standard Mathematica practice of working with large expressions / whole data at once.

@WReach How would "NativeValues" be fundamentally different from UpValues and DownValues we can use now?

@LeonidShifrin I'm imagining a hook into the evaluator itself, to create peers to the legendary "built-in rules". Of course, it would necessitate WRI publishing more details about the internals of the evaluation process... :)

@WReach But the only conceptual difference between built-in rules and user-defined ones is that they are always present from the start, and can not be manipulated in non-trivial ways (other than being Blocked or overridden by user-defined rules). Plus of course, they run faster. Which aspect did you mean - finer control or the speed?

@LeonidShifrin The main purpose would be to create high-performance constructs like images and graphs. Or maybe to take a crack at scoping rules without wrestling with the renaming system.

@LeonidShifrin But isn't it that some functions don't work by DownValues, but by direct calls into the main Mathematica dll?

@WReach Ok, I get the idea. That would've become possible, at least in part, if LibraryLink would be extended to work with arbitrary expressions, I guess. Although what you describe is more than that.

@halirutan I am not sure. I have to shamefully admit that I didn't do any kernel-level work yet (the stuff I was doing didn't really require that). I do know though that there are internal DownValues etc. And my guess is that the default mode to add new kernel functions would be through that road, and such direct calls, even if exist, are reserved to really special cases.

@LeonidShifrin You "were" doing? Is it done?

@halirutan But certainly functions you call via LibraryLink are like that.

@LeonidShifrin OK, then you have to trust me.

@Rojo I should've said I have been doing, sorry.

@LeonidShifrin Oh, ok. I was about to congratulate you on finishing the by far hardest project you've co-worked, whatever it is :)

@halirutan Probably also all numerical functions on packed arrays (their type-specialied branches) are direct calls to the kernel.

@Rojo Too early for that. It's not finished yet, not at all. But thanks for your intentions )

@LeonidShifrin Something like Pause[..] is directly mapped into the C level.

Listable functions tend to put one in a dilemma

If you make them listable, you can't optimize it treating the data as a bunch. But built ins can do that

@halirutan Never tried to override it. Doesn't it work if you add your own definition for Pause?

@Rojo You also can do that, if you use Compile with RuntimeAttributes -> Listable

@LeonidShifrin But you can't have a listable general wrapper

as Plus does

with the listable attribute

@LeonidShifrin Yes, I'm sure it works. What I meant is that the evaluator won't do much in the default definition. It just passes it down and the result doesn't come from the evaluator and DownValues. If you add rules, you can surely change it.

@Rojo But it is not clear to me how much built-in Listability gives in terms of performance for general wrappers, as compared to user-defined Listability

@halirutan But that would mean, probably, that Pause etc do have internal DownValues, which map straight to kernel calls. At least, that would've been consistent. And that's how it works, as far as I understand (at least, that's what I've been thinking). Surely I should find some time and learn more about it.

@LeonidShifrin I mean, say I want a function that is listable "in spirit". Say myPlus. When I do myPlus[bigList1, bigList2], it will always thread, and there's nothing we can do about it, right?

Even if we could implement a compiled version that handles the packed arrays, or whatever fast overload for the bunch

The only way out is to not make it Listable, which is a compromise

@Rojo You mean you spoil possible optimizations by setting Listable, because it is applied to early in the evaluation sequence, right?

Right

and at least a couple of bulitins work around that

@LeonidShifrin That's what came to my mind at first when I heard WReach's nativeValues :P

Some kind of early hook

@Rojo I agree, this would've been one good application of them. Generally, I think, what we are coming to is to have a more customizable evaluator. That would've been very nice.

@Rojo The proper way of doing that, I think, would've been to implement a core evaluator as a very simple one-step evaluator, and expose its API to the user, while the "real" evaluator would've been implemented on top of that one, being just one of the possibilities. But that would be significantly harder to make fast and robust.

@Rojo Perhaps, that would require to implement Mathematica in Lisp and make it open-source, at least the core evaluator :)

@Rojo And also, throw in some clever JIT-compilation

@LeonidShifrin Hehe

No realistic middle ground?

@Rojo Doesn't look like one exists, to me.

@Rojo I mean, all intermediate solutions will be point solutions, with different degrees of flexibility, and I am afraid that they will also add huge complexity, totally destroying their purpose.

I see. Ok

C'est la vie

@Rojo I think this is also related to a general question of how would systems B and C inter-operate, if both have been derived from system A as different extensions of it.

@Rojo The only way I can see this happen is that A, B and C define languages, and both B and C are compiled into A.

@LeonidShifrin I was just thinking that there would be more extension options if the Mathematica compiler could work with symbolics. Compiled code has more conventional scoping semantics, and if symbolic code could be executed at near kernel speeds, then all kinds of new constructs could be built without making radical changes to the language.

@WReach Yes, I agree. But symbolics means pattern-matching (when we talk about Mathematica), and Mathematica's pattern-matcher contains parts which are probably pretty hard to compile, and I don't even mean calls to the main evaluator. Patterns involving __ and ___, for example. But I am sure that some form of compilation is possible, it just seems to not have been explored sufficiently.

Sorry, back. I was cleaning the kitchen mess before it was too late

@Rojo Sorry about your kitchen. Hope it wasn't too bad.

@LeonidShifrin Not really, just sauce all over. I've done worse

like toaster on fire, burgers turned into smoke, or a recent one, plastic

OK guys. Day is dawning. I should go to bed. Nice to talk to you all. See you.

Bye

@halirutan good morning :)

@Rojo Well, sounds like a lot of trouble. I still remember cops coming to our dorm periodically, when I was on my PhD, sharing an apartment with a few others, and some of us was forgetting to switch off the stove )

@halirutan See you!

@LeonidShifrin Hehe. Cooking needs patience

@WReach Hehe... Know what I hate the most? The birds singing.

Bye.

The patience required not to leave stuff hoping to remember to go back to it in time

@Rojo @WReach It is 7 a.m. here, so I better go get some sleep too )

@LeonidShifrin Go, you obsessive worker

Sleep

@LeonidShifrin see you, thanks for the chat.

@LeonidShifrin Wtf? I though you were already up??

@Rojo Well, that wasn't exactly working )

@halirutan Oh no :)

@WReach Thank you too! See you!

@LeonidShifrin I hope you are not just talking about the last half hour. Sleep well

@Rojo Thanks! Later.

@Rojo Did you survive your soccer? Or it that your next of kin typing and about to tell us about a giant red icicle standing at the top of the box (a rojocicle?)

@Rojo I mean, talk to you later

@WReach Hehehe. I survived, but

Summary of the game: game started, I was energetic. A few minutes in, I made a goal

a minute later, I lost an easy ball, which led to a goal of them

a minute later I got tired, went back to defense, and tried to survive for the rest of the 50 minutes

who won?

They won :S

but, I play again this friday. I hope I'm fitter

I hate not being able to run

I used to be the fit energetic guy at school. Now I'm the fat asthmatic one

This has to end

:( Soccer was my game too. I say "was" due to 1) the ravages of time and 2) a kick to the knee while playing karate a couple of years ago. I miss chasing the ball around.

@WReach Uhhhh, that sucks

@WReach How is your knee now?

@Rojo It gets stronger every day, but I haven't dared playing soccer again, or putting the rollerblades back on. I plan on the latter sometime this year. We'll see.

@Rojo I was looking around for queueing evaluations last night, and I stumbled into CheckAll. I had never heard of it -- did you know of it?

CheckAll, that is.

@WReach Haha, glad you edited. I was confused trying to find the irony

Soccer isn't a nice sport on your injuries

but rollerblades are more preductable, you can take it slow and see how it goes

@WReach I don't think I've seen CheckAll

@Rojo That is the plan.

@Rojo I got totally distracted exploring what it does and ended up posting a reallllllly late answer to the "resource management" question.

@WReach It has even a usage message

@WReach I'm checking out your answer

@Rojo It goes back to at least V7. If the battery weren't dead on my old 68k powerbook, I'd fire up V4 and see if it was there.

@WReach That's veeeery interesting.

And I don't even recall having seen the question

@WReach And all answers are long

@Rojo I have an older version of UnwindProtect that I have been using for years (based on the old stackoverflow post), but I'm going to switch to the new one and see how it holds up.

@WReach I'm trying an idea, hehe

Useless at this point given the alternative

@Rojo I wait with anticipation :)

@WReach It does some weird stuff some times, but perhaps there is a "right way"

This is the idea:

Block[{$aux},
 Experimental`ValueFunction[$aux] =
  Function[Null, cleanupCode;
   Experimental`ValueFunction[$aux] =.,
    HoldAll];
 code;
 ]

Perhaps if one checks for the one arg version

Anyway, useless

Nice catch. It's surprising that there are still core functions in System context that none of us has seen

@Rojo Hey, that is some clever thinking. Alas, I tried a Throw out of the block, and the cleanup didn't happen.

@WReach I see sometimes when I change code, the first time it's weird, but the second time I run the same thing it works

@Rojo I was about to say the same thing. The order of execution appears to be a bit non-deterministic. Sometimes the code runs after the clean-up. It seems like some internal queue has a left-over entry or something.

@Rojo It should have worked, so I still declare it brilliant.

@WReach Perhaps the order is because of another thing. Try checking the num of args

But true, it's weird

Anyway, if there wasn't a perfect alternative, I'd keep on fighting this

This chat seems to be very active, compared to other chats on SE, even though the mathematica.SE site itself is not one of the biggest ones. I wonder what could the reasons be.

@Rojo It might be worth playing with anyway, these things frequently yield new insights into the black box.

The Wolfram Box

A new kind of box.

No more thinking outside the box

@Akater We Mathematica users must be desperate to talk of others of our kind :)

@Akater exactly

I was happy that one of "my students" had decided to do this semester's project with MMA

but, he had some trouble and now he went with Octave

Obviously, I'm going to solve the project in MMA and show off

@WReach Sure. :-) But that alone doesn't really explain it. The community is amazing by general standards, IMO. Lisp programmers don't have anything like that, and 1) I think it's an overall reasonable comparison; 2) Lisp has been around for much longer.

@WReach I'm not sure it's possible to explain easily… but just can't let this go, keep asking myself what's so special here.

@Akater On weekends the chat is emptier

so I guess we are very social people when we should be working

@Akater Yes, you are right. I have always found the Mathematica community very supportive. I have spent some time in the Lisp community as well, and IMHO it was nowhere near as supportive (perhaps I am stating that mildly). I am at a loss for explanation as well.

@Rojo I'd better wrap up, or I'm going to tumble down the same hole that had Leonid and Halirutan watching the sunrise. Nice talking to you. Bye!

@Akater Bye!

@WReach Bye, good night

@WReach Bye.

@Rojo :D

@Akater Today I was at the English chat for a few minutes, and they seemed nice too

and it was active

but, I'm sure the site is way bigger than this one

Cute: reference.wolfram.com/mathematica/ref/message/…

Maybe? Hah

@Rojo Someone was getting bored, I guess.

What do you think about reporting errors in the output and not via Messages? Like, If[smthIsWrong, "Error"[details], _] or maybe If[smthIsWrong, (ToExpression@"Error")[details], _], so that errors are handled depending on end-user's definitions of Error symbol? I understand that 1) it's non-conventional; 2) in case of $RecursiveLimit and $IterationLimit errors user won't see anything. Are these the only drawbacks?

After all, it's quite the same as $Failed, only with additional info inside.

@Akater I think you're mixing error handlers with error messages. What you're describing is not uncommon as a programming concept, but is perhaps not very common in Mathematica. Nevertheless, it exists in built-in functions such as Interpolation which allows you to specify an error handler.

If I were you, I would probably have some sane defaults for these and provide the user options where they can override the default error handler and silence the message. I wouldn't probably combine the message and error handling, since they both serve different purposes.

Options[foo] = {"ErrorHandler" -> default, "ShowMessages" -> True}
foo::err = "error!"
foo[] = Module[{errorHandler = OptionValue["ErrorHandler"], showMsgsQ = OptionValue["ShowMessages"]},
    Catch[(* code with Throw[If[showMsgsQ, Message[foo::err]];$Failed, tag] *), tag, errorHandler]
]

Probably something loosely along the lines of the above code... Perhaps someone like Leonid might be able to articulate this better.

@rm-rf “mixing error handlers with error messages” — probably so, I can't see the difference for now. Thank you. My point is: when f calls g, and g has side-effects, f might need to know what happened exactly. One could use error codes but this way it quickly becomes human-unfriendly, and then one has to separate messages and handlers, thus opening a door to the whole new hell of work that seems unnecessary — this being, of course, a naive non-programmer's point of view.

@rm-rf …Arguably, messages as provided separately make it harder to read the program's text; when errors are merely evaluated at certain points in program, it looks more natural, at least to me. I didn't find it illuminating when error messages were gathered separately, outside of program's body.

@Akater f can check if g generated a message, if that's what you mean. reference.wolfram.com/mathematica/ref/Check.html

@MichaelHale Thanks. I've come across Check some time ago but it didn't stick. Maybe I should revist it.

@halirutan Hello, are you around?

@JacobAkkerboom Maybe you? :)

@Kuba heya, let me see :)

ToString[Unevaluated@
  NumberForm[2.1, {4, 1}, NumberPoint -> ","], InputForm]

@JacobAkkerboom I'm too old. I've done that but without `StandardForm...

@Kuba we are all too old, but please don't say it out loud :P.

By the way InputForm vs StandardForm matters here. Not that I really understand

Also as per the linked Q&A, be careful, the following may be unexpected:

ToString[Unevaluated@1*^12, InputForm]

-.-

@JacobAkkerboom so it seems it is not an answer

@JacobAkkerboom it fails also with: ToString[Unevaluated[(2)], StandardForm]

@Kuba yeah, em, I'm not sure what everybodies goal's are, but if the goal is to get the boxes that should correspond to a "string" in the front end... That seems quite impossible

@Kuba also f@x and x//f should fail

@JacobAkkerboom why why why? :) the second answer with InputField~Boxes can handle this.

@Kuba I don't know of any way to get the string that you see in an input cell. To get it from the boxes even doesn't work smoothly, IIRC you get to many brackets often

@Kuba yeah, there the input is entered as a string. Not as some strange box expression which is changed with every keystroke :P

@JacobAkkerboom I suppose I have to make a clear statement what I do I need and when. I think the fact CurrentValue[nb, "SelectionData"] is working without interpreting the code is promissing

@Kuba I think I once wrote quite a long answer containing a parser... getting the string was also an issue there. I receiver bounty from you I think. CopyToClipboard also kind of works :P

@JacobAkkerboom Indeed.

@JacobAkkerboom It's better than explicitely typing " "

@JacobAkkerboom Do you think stripping all the RowBoxes may be dangerous?

@Kuba hmm I'm a bit confused :P. Let's just hope all of this becomes possible in v10 :).

@Kuba not sure. brb

@JacobAkkerboom Yes, it can be :) jhp["\!\(\*SuperscriptBox[\(x\), \(2 + 3\)]\)"] //. RowBox[{x__}] :> x

But I think avoiding 2D input will be enough to say it's safe.

@Kuba I'm having a hard time saying something constructive about this right now. I would have thought removing the RowBoxes would be safe. But you don't want to pass a sequence to BoxData, which I think is what happens in your code. Consider

jhp["ContourPlot[Mean[{x+y,x y}],{x,0,1},{y,0,1}]"] //.
  RowBox[{x__}] :> x // #[[1]] &

@Kuba ah good point. Maybe you can only merge nested RowBoxes into one or something

@JacobAkkerboom Not nested but neighbouring I think. But that's not so important now :)

twitter.com/WolframResearch/status/471195332358189056/photo/1

Maybe they could stop giving peeks if they don't have any plan when to release it... I paid for one Mma upgrade (old v8 to v9) early this year as they promised that gives me free v10 upgrade. I'm still waiting for it...

@kirma :P

Nobody knows, maybe it's finally coming soon-ish. At least missing stuff in prerelease documentation has been mostly fixed.

@kirma I'm not excited anymore :) it will be when it will be :p

:I

@Kuba Right and everyone should know the advantages when a beta-product is tested carefully.

@Kuba Did you solve your problem already?

@halirutan in some contexts, but I'm not sure what do I want :P

@JacobAkkerboom (@Kuba) Something like 1*^12 is a special input form and cannot be hold or kept unevaluated. Before the evaluator sees it, it is already turned into something else.

not full automatic ofc but may be enough for many purposes

@Kuba What do you want to do?

@halirutan My point exactly, this is also the case for prefix and postfix in f@x and x//f. :)

@halirutan I've said. I don't know!!

:p

@Kuba Ah, so it was more like a I wonder how I can do this but I don't specifically need it question?

@halirutan yes :)

and it's the case where is does matter :)

the context*

OK.

@Öskå do not spam the comments, that's why this chat exists :)

@Kuba Me spam? Never..

@kirma doc update? There is a lot of missing doc yet, but they update in bunch, so, it's not a good way to measure when it will be released. I'm curious to see how Query will work.

@Akater I think there is a simple explanation. Mathematica is more than a programming language, it is also a very high-level thinking laboratory. You can express your ideas for a rather wide range of topics very concisely, and programming is often secondary to actually expressing those ideas. Besides, many (most) of the regulars here are not hard-core CS people.

@LeonidShifrin I don't even know what CS means :P

@Murta What would be interesting stuff to watch? I think most stuff on geometric computation and cloud whatever at least have been written, instead of showing a pseudo-popup box.

@Akater To put this differently, Mathematica is not just a single isolated world, but rather an intersection of many worlds, and most interesting things are happening at various borders, intersections, etc. The fact that it is a very high-level visual exploration tool certainly contributes a lot to how this community is shaped.

@Akater There are also other examples out there of very active communities around less known languages. For example, Rebol and Red chat room. Btw, Rebol / Red are to me some of the most interesting languages to look into. Some people say that Rebol is just a repackaged Lisp, but my feeling is that it is more than that.

@Kuba Let's say people with background in theoretical foundations of programming languages, as well as their implementations.

@LeonidShifrin sure I know what you are saying, it's about me :)

@Kuba I meant to say that our community is lucky (by nature of Mathematica and people who like it) to mostly stay away from the culture encouraging snobbish and arrogant attitude, which is alas characteristic for some of the more technical or "professional" communities (I've heard that about both C++ and Lisp communities, of course acknowledging that there are exceptions in both cases).

@LeonidShifrin So you are saying it was not about me, I'm the rude one?

I'm still kindding and you are..? :P

ok, let's leave those dry jokes.

@Kuba These comments had nothing to do with any particular person, you or someone else :)

I do love this community for diversity and enthusiasm.

@LeonidShifrin moreover, I think MMA requires patience from users! That's why it's nice here. Impatient folks already give up with mma as it is very often unintuitive.

@Kuba I tried to outline the reasons for this diversity and enthusiasm. I think languages define our thinking mode much more than most people think. To me, it is interesting to find which properties of a given language are responsible for certain features of the community around it.

@Kuba and my impression is that @Akater was interested in the same thing too.

@Kuba But I agree on patience to deal with unintuitive behavior. In a sense, when one uses Mathematica, it always feels partly like some experiment and / or simulation, where one can get something unexpected. That's an important factor indeed, although often it hinders productivity too.

@Kuba All right, gtg now. Talk to you later!

@LeonidShifrin ok cya.

There's a dirty-orange colored button on the main site next to the review button. It has a number on it. Clicking on it takes me to the review queue, but the number seems to have nothing to do with the number of items in the queue. I think it used to take me to flagged posts, which I no longer have access to. What's the button for?

@MichaelE2 I'd say it is brown :P Well I see it too, i think it refers to the number of questions that the voting in taking place despite the fact that you've already voted and can't see them.

@MichaelE2 This is your lucky number for today. It has nothing to do with the review queue.

:)

@halirutan Hehe

@Kuba cs = computer science :)

@JacobAkkerboom wtf :P are my jokes so dry, really?

@Kuba wups :P

@halirutan wow, I'm wrong then

I can see 4

@Kuba let me give you a hint:

You mean, let me bully you with sarcasm?

:P

@halirutan ...

@MichaelE2 I think now most user-viewable flags are routed through the review queue, so it serves the same purpose. The number though, is heavily cached and is annoying... it doesn't (in real time) exclude the items you've reviewed or are otherwise ineligible to review

@rm-rf Thanks. Must be the ones I can't see that makes the number seem random.

Rather a useless indicator (for me), then.

Expensive to update in real time, but the alternative is to remove the indicator (which means fewer people use it)...

I just check the queue when I have time and ignore the indicator.

@halirutan I'm wondering how did you create those images? They look so real.

@xslittlegrass You can use your web browser's web development tool to change the HTML. For example:

hi all, got a notebook with a bunch of plots of different sizes

i want to print this notebook, without clipping any of the plots

how can i do that?

Mathematica seems to ignore my "printout" style

@Guillochon Did you check that?

There are a few Q&A about printing and stylesheets

@Öskå Ah, it looks like the printing environment was set to "working"

I remember having issues when it comes to printing as well, is it "fixed" now?

@Öskå Sort of, although I have to make sure the notebook is in Printout style too before printing

@Öskå Otherwise, it doesn't match what's printed

I remember something like that as well.. :)

But if instead I type SetDelayed @@@ (ReplacePart[ ... and then add ??temp inside my module, it gives me information on Global`temp

oops as soon as I typed it out I saw the problem, hah

IMO your code is long and complexe enough to worth a proper question :)

Aw and that was my first chat question too :P

@Öskå first comment would be. What is ND, where lives c. :)

I also wondered what was ND :D It was blue on my screen ;o)

You have an issue with Cs today @Kuba :D

I don't it is me who has it :)

Oh sorry there was no context. I was responding to a question where someone asked about automating this question: mathematica.stackexchange.com/questions/22370/…. so it's NumericalCalculus`ND

ok

I changed it to doND just so i could see what was happening with my expression construction

Oh strange. It seems my problem is that ??temp resolves to Global`temp when inside a module, but Information[temp] resolves locally. Is that what I should have expected?

@Pickett Thanks a lot! That's really great!

fyi, multi-level undo in V 10 twitter.com/WolframResearch/status/471208308473597952/photo/1

@Nasser Thanks for the info :D It's about time :)

@Nasser Hmm, and indication that inclusion of multi-level undo will delay the release of V 10 by, oh I dunno, years?

@Öskå nice one :)

@JacobAkkerboom Did you intend to ping me? :P What did I say? :o

I liked your joke: "You have an issue with Cs today @Kuba :D" :). See the little arrow to the left of my message. If you mouse over it (or click it), you can see the message I am replying to :)

Oooh, I didn't notice that :P

@Öskå yeah I also always used to miss it. Probably still do :P

@JacobAkkerboom @Öskå Do you think it is siesta? I can't handle vague questions almost alone :P

@Kuba yeah, lot's of low scoring questions I guess. Let's see

@JacobAkkerboom gtg? pff -.-

:)

lol

:)

I wonder if that's from production code that has been there from late eighties... ;)

Such source code archeology is interesting masochistic endeavour... occasionally.

:)

But what's that commented out CurryInformation?

Ah, maybe I get it, but why is it capitalised?

Anyone interested in quantum computing ?

qcplayground.withgoogle.com/#/home