Announcing Wolfram Programming Lab
blog.wolfram.com
blog.wolfram.com
If they would make their stack FOSS they would be absolute heroes and shape the future of applied math and computation software with a historic impact. Otherwise they will fade away, when other interfaces (Jupyter & Co.) catch up and/or surpass it in its capabilities. More and more people will just not accept the closed nature as it inherently contradicts with the idea of exploration.
There are basically 3 scenarios:
- they go FOSS now: best outcome for people and Wolfram
- they go FOSS later: good outcome for people, more difficult for Wolfram, as they lose developers/community
- the don't go FOSS (or not in near future): Wolfram SW won't be used anymore as open alternatives surpass it. People won't care.
Even Microsoft got it.
If you have a smaller problem, first type it into mathematica, and see if it comes up with an answer. It means that you don't have to divert your efforts into that small problem.
That said, mathematica has a function to have it explain exactly what it did to solve a particular problem. Example:
The difference between Mathematica and other environments is that in the latter, you ascend from the trivial to the abstract, hopefully learning the entire structure as you go, but with Mathematica, you're deposited on a mountaintop with no obvious pathway down.
> That said, mathematica has a function to have it explain exactly what it did to solve a particular problem.
Yes, but this doesn't work for the more advanced features. If it did, someone could simply copy down the conversion sequence and recode it for a different environment. As a result, Mathematica users are in the position of accepting results whose genesis is concealed.
There's no viable alternative to Mathematica, let alone a compatible one. Even for the basic stuff I've used Mathematica (student license) for, basic symbolic integration, differentiation and simplification, I get inferior results from Sympy and Maxima. I haven't tried XCas yet, some say it is better.
And this is only talking about the computer algebra capabilities. Mathematica has all sorts of nice tools for doing plots, interactive UIs and other stuff.
No reliable statistics, only the conjecture that Sage, sympy and other such environments allow people to produce a significant percentage of the results Mathematica can produce. Mathematica still has a substantial territory of advanced results unmatched by the free environments, but the gap is narrowing as the years pass.
I know this -- students are much more likely to acquire Sage or IPython than purchase even the lower-priced student version of Mathematica, simply because they can get the former for free, and there's plenty of high-quality documentation and examples available (example http://arachnoid.com/IPython). And how many undergraduate courses require the kinds of advanced results that only Mathematica can produce? And given those specific results, in an academic environment how much of a penalty is it that only the result is produced with no explanation or context?
* Even when it succeeds, it doesn't necessarily give you the simplest possible form of the solution.
* It is concerned with elementary functions, but real-world problem often involve non-elementary functions (like Bessel and hypergeometric functions). You can extend the Risch algorithm to work with such functions, but this is complicated.
* It doesn't allow computing parametric answers for common parametric families of integrals (this needs to be done using heuristics and lookup tables).
* It doesn't give you an algorithm for definite integration, except in simple cases. Even with proper definite integrals, you need to be extremely careful with branch cuts when applying the fundamental theorem of calculus. For improper definite integrals, systems like Mathematica generally try to go via convolutions of Meijer G-functions, using huge lookup tables and simplification heuristics.
* Even more fundamentally, the Risch algorithm (and symbolic integration more generally) puts heavy demands on the underlying symbolic computation engine. In particular, it depends on the ability to decide whether an expression is equivalent to zero, which in fact is an undecidable problem, and this strictly speaking makes the Risch "algorithm" a non-algorithm (though it is a proper algorithm when restricted to a ground field where zero testing is effective, such as Q).
Given enough time, it will happen. There are several reasons. One, people who publish mathematics academically are reluctant to use a closed-source tool to create their results, because those results can't be examined and verified at their source. This issue pushes people toward sympy/Sage/Jupyter and other similar open environments, even though at the moment they aren't as powerful as the Wolfram environment.
For example, imagine that the four-color map problem (the first significant computer-aided result in mathematics) had been solved by a close-source environment (instead of an open, freely readable source as it was). If that had been true, people would still be arguing about whether the result was valid.
Two, an open-source environment like sympy attracts technically skilled people intent on improving it, knowing that they're contributing to a tangible kind of progress that's clear to everyone, and then freely copied by like-minded people into different environments, all with the intent to advance human knowledge, rather than make stockholders happy.
Three, this may not be apparent, but the existence of environments like Sage and sympy are putting tremendous pressure on Wolfram to price their products more reasonably. Instead, and so far, Wolfram's strategy has been to design enticing free samplers like Wolfram Alpha as gateways to their expensive offerings.
> If when I'm buying Mathematica I'm paying for a proper implementation of the risch (integration) algorithm, it will have been money well spent.
This is a perfect example -- until Mathematica is open-sourced, no one can know whether the existing algorithm is either complete or optimal. Also, given that research into this algorithm has enormous practical value in both mathematics and computer science, it's a shame that a large segment of the effort is being carried out in secret. I'm sure those responsible for its present form would love to publish their results, if only for the fact that this would get them fired and possibly prosecuted.
There was a time when people who made an original contribution to human knowledge would publish their results in the open (think Einstein) and take pride in their contribution to the common good. It seems those days are past.
Mathematica isn't magic and the source code for your mathematica program is perfectly readable text. Reproducing the result from a mathematica program without mathematica is often time consuming and occasionally painful, but it's rarely a hard problem. So if the four-color map problem had first been solved using Mathematica, it wouldn't have taken many weeks for the solution to get reproduced in a different languages. Hell you could probably reproduce the necessary code just from reading the paper without ever looking at their source code.
Yes, but the user's program only tells Mathematica what to do, not how to do it. How Mathematica does it is proprietary, and this represents a serious transparency problem for academic work and publication.
> Hell you could probably reproduce the necessary code just from reading the paper without ever looking at their source code.
If this were true, Wolfram wouldn't be able to charge thousands of dollars per copy of Mathematica. The reason Mathematica is expensive is because of what it conceals, not what it reveals.
Being a customer doesn't save you, BTW: Giving them money insulates you not one whit from their decision that a course of action which destroys your whole setup will get them more money. This doesn't really change even if you have a contract: Unless you convince a thoroughly insane court to order some form of specific performance, the most you're entitled to is, essentially, a refund, maybe some punitive damages, and Wolfram no longer caring about you even to the extent they previously did.
I like open source, but I _have_ to use mathematica to be as productive as my peers in my field. The open source tools that exist are indeed inferior and that's why I cannot use them.
However, this is not a good argument, as my field is physics. I do believe that the use of mathematica for science is a inherently bad thing, and should not be considered an allowed part of doing science -- because it is closed source.
I consider the reductionistic part of science very important, so when I use some function in mathematica I do not know exactly how it is implemented hence I cannot reduce my result beyond the point of "Wolfram says it is ok.". But that is not ok.
I have been lucky with all of my results, in the sense that one can check them by hand or by inferior products. But finding the result to begin with is why mathematica is almost necessary for a lot of calculations.
Open Source is just the ultimately precise but horribly inconvenient documetnation.
Since mathematica is so much faster and feature rich people use it and only very occasionally is it verified by some other software. I would prefer, and would make things easier and faster, if we had (verifiable code) + (one result), instead of (no code) + (one result) + (independent check of result), since only rarely one bothers/have the time to make the independent check. In some cases there is no option to make an independent check (e.g. "with enough effort" is usually too much effort).
Can you be more specific? It might be interesting to hear if people found viable solutions to specific concerns.
At one point I was using SymPy and I wanted to invert a symbolic matrix, a rather small one but it had some off-diagonal elements. This took a few seconds in mathematica, after a few hours in SymPy I had to halt the execution of that line. I never got around to look at the code to see what caused it, probably some simple bug, but that's another reason.
I have used Sage somewhat as well. It has more features than SymPy, for what I do professionally. Still some features are missing that I would need. But this might also just be a problem of the amount of experience I have with these tools.
The last problem is that these are much slower than mathematica. I would certainly not say that I'm a good programmer, so my code is probably very slow and badly written. In mathematica I have done some calculations that take days to complete, but they were quite heavy calculations. For these projects I could in principal have used SymPy, I know it has enough features, but with how much slower it is, it would be useless (unless I was able to improve my code to compensate).
With more experience I could give more specific concerns.
As another example, when will we have FOSS Notebooks that can match what Apple is doing with Playgrounds?
Having the means to the right funding makes a lot of difference, specially when many seem to be wary to pay for developer tools while gladly pay for any physical tools.
Smalltalk, well being Smalltalk.
Oberon being the product of Niklaus Wirth, after he learned Mesa/Cedar while at Xerox.
That experience, coupled with lots of archaeological digging for old manuals and papers is how I got to learn about it.
Basically Xerox had three workstation environments, Interlisp-D, Smalltalk and Mesa/Cedar.
All enjoying the fact of the workstation and OS blended into each other.
The CLI was a REPL, so you had full access over the OS. Any public API could be accessed in the REPL, you could interact with running applications, all the same way.
Also the REPLs were graphical with inline generation of data, so imagine something like Swift Playgrounds as the CLI.
Lots of nice documents here:
https://archive.org/details/bitsavers_xerox
Filtered by language:
https://archive.org/details/bitsavers_xerox?and[]=subject%3A...
https://archive.org/details/bitsavers_xerox?and[]=subject%3A...
https://archive.org/details/bitsavers_xerox?and[]=subject%3A...
So these workstations where an whole stack OS.
You can read about their implementations on the links I provided before.
Additionally, you can get the original Smalltalk-80 from from Stephane's web site.
http://stephane.ducasse.free.fr/FreeBooks.html
This is a very ruft idea how it felt to use a Smalltalk workstation:
https://www.youtube.com/watch?v=8yxCJfayW-8
https://www.youtube.com/watch?v=JLPiMl8XUKU
The REPL was what is known in Smalltalk as transcript.
Similarly the Interlisp-D workstation also had they own mixture of REPL and editing
https://www.youtube.com/watch?v=wlN0hHLZL8c
Some of the ideas that lived on the Lisp Machines afterwards
https://www.youtube.com/watch?v=NOysrxexTXg
https://www.youtube.com/watch?v=o4-YnLpLgtk
Mesa was a memory safe system programming language created at Xerox, as an evolution from Extended Algol to replace BCPL. Niklaus Wirth based his Modula-2 design on it.
Shortly thereafter they updated Mesa into Cedar, which added support for RC with local GC for cycle collection. The system then got called Mesa/Cedar.
It allowed the same interactive experience as the other workstations, but using a GC enabled systems programming language.
The REPL provided nice features, like auto-suggestion when a typo would cause a compilation failure. It is also probably the first graphical debugger for a strong typed language.
Any OS API could be used on the REPL by typing modulename.procedure , which could use other OS APIs to get its input from different sources.
An idea Wirth adopted into Oberon.
You can see how all three environments looked like here:
http://www.chilton-computing.org.uk/inf/literature/books/wm/...
And yes, Powershell alongside .NET is probably the closest we have in modern computers to those systems.
Followed by Swift Playgrounds and AppleScript on Apple systems.
Although Apple also provided similar experiences with Common Lisp, Hypercard and their NewtonScript and Dylan.
MIT Lisp Machine screenshots from 1980:
http://bitsavers.informatik.uni-stuttgart.de/pdf/symbolics/L...
Yet another proof that the success of AT&T meant a left turn.
Symbolic integration, differentiation and simplification just works miles better in Mathematica than any of the open alternatives I've tried.
It's quite common that the open alternatives just choke on something quite simple. In Mathematica, you can just use Simplify[] to get a nicely simplified expression. In Maxima/Sympy, you might be able to get the same result but you need to understand how the simplification algorithms work, ie. you have to choose which simplification method to apply based on the task and might need to apply more than one method to reach the goal.
Additionally: Mathematica is pretty darn simple to use and well documented. Going through the docs of Maxima, Sympy, etc requires you to be a domain expert in computer algebra. I am not. I just want something to assist me when a basic algebra task would require several sheets of paper and I'd be likely to make mistakes.
I am not even going to talk about the UI, plotting and other features. I haven't used them much.
I have not tried XCas yet, perhaps it's more suitable for my purposes. Some commercial calculators (ie. physical devices) are based on XCas.
note: I've been mostly working on some basic university level physics related to space flight and orbital mechanics. Stuff like Kepler's equations or rocket equation solutions.
... and instantly stop making money. I have the impression that making money is quite important to Wolfram Research.
You may be right that in the long run they're bound to get their lunch eaten by free alternatives, but "in the long run we are all dead" and it's really not surprising if they prefer "continue making lots of money from selling Mathematica, and maybe one day find that free alternatives take away our market" over "immediately make vastly less money from selling Mathematica, but keep market share for this big codebase we can no longer make much money out of".
Also, open-sourcing their stack would mean relinquishing a certain amount of control. Have you ever heard anything about Stephen Wolfram that would suggest he'd be OK with that?
However, it would be nice if they would open source parts of their application so bugs could be fixed in the user-facing parts. Even if their engine remains closed, the UI could be open sourced. I'm fine with them keeping their "secret sauce" proprietary and asking money for it. They spent decades making it work.
I am saying this because Mathematica for Linux doesn't work great. It's violating the X11 protocols and doing some crazy things with XSendEvents, which makes it not work at all on some window managers (window layout is completely fucked, mouse clicks aren't received properly, etc), while other WMs (e.g. i3wm) have Mathematica-specific hacks to ignore some of the messages it's sending.
I'm not sure what to do with this situation. For some of my projects (outside of paid work), I'd need Mathematica. So far I've used an educational site license for my university but now I've graduated and I won't have access to that.
So I could pay them $130 (student license, I still have my @uni.edu email for now) to $300 (normal license) but I don't know if they'd fix the issue. I could start using a more mainstream desktop setup (KDE, Gnome, whatever) in the hopes that it works, but that's not ideal either. I have not contacted customer support because I'm skeptical that they would do anything for such a small minority of their customer base.
Mathematica is almost the only closed source application I'd need. The open alternatives are not good enough and I'm not educated enough to improve them.
I subscribed to their online offering when it originally came out, but immediately canceled because the UI is just so far behind its desktop competitors, like Maple, and even Matlab. I want to support this software, it has great potential, but they need to sit down and really rethink how it's put together and delivered to the user.
Then they decided to hop on the Java bandwagon, and rewrote their whole UI using some kind of cross-platform Java GUI toolkit. App startup time went from like a tenth of a second to like 30 seconds (at least, that was my subjective impression at the time). Every part of the GUI was laggy and glitchy, it crashed regularly, the documentation was reorganized and much more confusing, etc.
The big-ticket feature additions which supposedly justified the rewrite were some gimmicky stuff for writing formulas in a more standard-math-typography way instead of as plain text, plus some related handwriting recognition thingy, but this ended up being slow, confusing, and ineffective, and cluttering up the rest of the interface.
This was before I learned "real" programming, so I actually stuck with the Java GUI to get the pretty-printed math formula editor. Still, maybe that experience caused me to avoid writing Java programs later on...
- No setting of the platform's L&F
- Everything is done on the main thread
- No care is taken about how to write GC friendly code and data structures
- No attention to eye candy
It is like having Assembly developers cry at the shitty performance of C compilers in the early 80's and blame the language.
I still use Maple mainly because of familiarity. I've been using it since the 90s. I'm a contributor to SymPy, but even then I can think through the problem quicker using Maple.
+ Making instant web apps and APIs just by specifying two functions -- "front-end" and "back-end".
+ Easily creating impressive-looking programmatic 2D and 3D graphics and sounds.
+ Innovative idea making visible graphics and colors as arguments and outputs of functions.
+ "Knowledgebase" of facts accessible using natural language. (Though, this was often slow due to server calls.)
My main critique of Mathematica is that it is the epitome of a kitchen sink library. There is an overwhelming number of functions for every possible thing. So, it is often not feasible to know what is offered without a lot of reading. (In fact, Wolfram even states this in his book.)
This is the real problem with their "knowledgebase". I would love to enter any natural-language query and get an answer, but in reality I need to check their list of supported areas and know the seemingly arbitrary list of facts about each area. To really make this useful, Wolfram has to figure out how to make it work without requiring me to be so knowledgeable about what it contains a priori.
Also, having such a large standard library makes the language very "flashy". It is indeed impressive and inspiring to create a sphere or musical piece in one line of code. However, real programs end up being much larger. In practical programs, Mathematica's functional syntax results in long unwieldy statements with forced formatting. This is occasionally impressive, but it is just as often hard to decipher.
Mathematica has plenty of problems, like it's extreme slowness for things that should be comiled, and awkward reference passing, but the ones you've pointed out don't really make sense to me.
If you're running it locally, there's a very practical reason to complain: between Wolfram 7 and 8, the application bundle size went from 29 MB to 2.65 GB. That's not a typo.
However, this also means there is an enormous, aging codebase that Wolfram continually must maintain and add new features to. It means that coders from different communities (who use different sections of documentation) likely have very different standard practices. And, I am concerned that this philosophy of "always having to look everything up" really hinders their knowledgebase product due to lack of consistency.
However, I applaud Wolfram for the ambition and enthusiastically sticking with it over so many years.
http://www.leancrew.com/all-this/2012/04/where-modules-go-to...
In the short term a kitchen sink of predefined functions are great, but in the long term they become baggage that holds a platform back (and there's no way to improve them without breaking backwards-compatibility). They're usually a sign that the platform has its priorities wrong: you need a good dependency management solution, and once you have that there's not much value putting things in the standard library. (Look at Scala, which is going to a lot of effort to carve things out of the standard library so that they can be maintained separately with their own release lifecycle).
I really think this is like an Apple vs. non-Apple situation. Sure, the Apple ecosystem is closed and not as flexible and you can think of all these problems that it could get stuck on. But in practice for the large majority of Apple's target audience, these concerns don't pan out. And the benefits of that system are large.
How exactly do these functions work? Can you specify a front-end that's outside of the wolfram platform/domain?
CloudDeploy[FormFunction[{"photo" -> "Image"},
EdgeDetect[#photo] &]]
CloudDeploy[FormFunction[{"place" -> "Location", "radius" -> "Quantity"},
GeoGraphics[GeoDisk[#place, #radius]] &, "PNG"]]
It uses JavaScript (support for node 0.10 through 5), and instead of being one giant library made by one company, connects you to every version of every package on npm (that's 200,000+ libraries!). Anytime something is published on npm, it immediately becomes available on tonic, allowing you to work with the "global standard library". If you use something like D3, you can do math visualizations: https://tonicdev.com/tonic/d3-example-from-beaker . Alternatively, you can use async and await to play with APIs: https://tonicdev.com/capicue/iss/4.0.0 . When you're done, you can hit download and run it on your own computer using node.
http://www.wolfram.com/mathematica/customer-stories/predicti...
"""Fannie Mae financial economist Bernard Gress is taking an innovative approach to predicting the stability of mortgages. He's using Wolfram technologies [...]"""
Translating out of Wolfram-ese:
"simple code doing interesting things" -> expressiveness
"knowledge-based programming" -> lots of libraries
"uniquely made possible by the Wolfram Language" -> we have the best libraries, and therefore the most expressive language
Stephen Wolfram is a font of interesting ideas that deserve attention. He really is an intelligent and perceptive guy. The problem is he's so arrogant that he consistently ignores (or, when he does acknowledge it, belittles) what others have done. I find myself unable to trust anything he writes or does because it's always filtered through the lens of his own brilliance - I intuitively expect that such a person will ignore serious problems with their own work because it's a threat to their ego.
I think we should look very carefully at his ideas, work out what they actually are (instead of what he thinks they are because he's not a reliable source) and steal them.
But then I wonder, is that just because I see people who are skilled in the art or is it intrinsic to the language? If it is so powerful, how come I don't see more of it being used? Is this just because it runs on a closed system? So does Matlab, but at least in my experience Matlab seems more widely used, why is that?
Yes and no. MATLAB and Mathematica have access to the same BLAS libraries. If you're using packed arrays in Mathematica, you can expect similar performance for many pure numeric things. Mathematica is missing some of the higher level primitives, there's no built-in function that corresponds to DGEMM, as a random example.
Another weakness is that there's only a handful of packed array types, for a 64-bit system, you get tensors composed of doubles, signed 64-bit ints, and complex numbers; no bool arrays, no unsigned 32-bit or 16-bit, no enum or factor arrays. Now this is purely a performance thing -- you can make tensors/arrays containing anything you want, but their contents just won't be 'packed' into a contiguous region of memory, instead they'll be arrays of pointers to other memory on the heap. Such arrays are slower to work with, much less memory efficient, harder to pass over an FFI, etc.
There's also a lack of fast workhorse-ish functions involving tensors, so there isn't a way to broadcast a condition (say 4 <= x <= 10) onto an input matrix to get a 'mask matrix' as is so common in MATLAB and R and so on, and one of their secrets to writing fastish code in a interpreted language.
On the other hand, you can deal with ordinary lists (and Associations) that contain arbitrary types (as with any dynamically typed language), which makes many kinds of algorithmic work very straightforward. After all, not everything is best represented as an n-tensor of reals or ints or bools! But if your lists do happen to be homogeneous lists of ints or reals (of any rank), they will usually end up being stored more efficiently as mentioned above, a process that is, for better or worse, totally invisible unless you know about Developer/PackedArrayQ.
There is also Compile (https://reference.wolfram.com/language/ref/Compile.html?q=Co...) which still has a fairly limited type system, but will still let you bypass large amounts of interpreter overhead when you need to do something performance critical.
> you wouldn't analytically solve a sophisticated PDE so you would use numerics
The whole analytic/numerical distinction really isn't true anymore (e.g. https://reference.wolfram.com/language/ref/NDSolve.html, https://reference.wolfram.com/language/FEMDocumentation/tuto...).
> so that explains why MATLAB seems more prevalent.
I think the explanation lies more with MATLAB having exactly the right features (or the right toolboxes) at the right time to fill niches in thousands of engineering and research labs. If you're running a lab, and that postdoc who wrote the code driving your instrument has long since left, there is very little reason to embrace a new language, even if it has caught up in various ways, and especially if that new language isn't tailored exactly to what you are doing, and would prefer you to use some strange thing called "functional programming", etc.
The Matlab comparison isn't that useful though, because the languages are geared toward different problems. Matlab at its core is linear algebra ("engineering"), while Mathematica is based on symbolic computation ("algebra"). That's a pretty huge difference. They have both branched out I'm sure, but the history remains.
People have a similar confusion over Matlab/Julia vs. R. They're both scientific computing, but R is for statistics. (R has matrices and linear algebra, though they are fairly terrible compared to the data frame operations, and seem second class.)
I would think of each language as having a core data structure:
1) Mathematica/Wolfram - expression/symbol
2) Matlab - matrix/vector
3) R - data frame (columns of heterogeneous type)
Mathematica can get performance on par with Matlab. I think the real problem is that Mathematica's performance can feel inconsistent to beginners (i.e. some things are fast, some are slow, and why they are fast and slow is not at all obvious.)
have a few more.
I also think marketing plays a part. Matlab has effectively sold itself as the go-to language for mid-scale number crunching (i.e. scientific-type problems that are complex enough where performance could matter, but not so complex that you need careful performance tuning or a supercomputer.) Mathematica can achieve similar performance in those sorts of problems, but in my mind, Wolfram has been presenting Mathematica as more of an educational/casual tool for one-off tasks.
I can't comment on cost or licensing offerings, but that could be a big factor as well.
It's good for scripts but I really don't see how you could maintain any sizeable project purely in Mathematica.
The same is true for MATLAB projects. Yet people do maintain sizeable projects in that. They're horrible, unreadable, and depend on various things in that specific installation of MATLAB that make any even medium sized program hard to even get running on another machine, never mind productionizing it.
But lots of people do it.
I love Mathematica and use it at least once a week. But these "free" versions are nothing but your first hit. And the Wolfram Language is not something you're going to figure out in the course of an afternoon with five notebooks.
Best to Wolfram. Lets see if this can become the pack leader.
A) Can I run my programs locally without connecting to the cloud? B) Can I dynamically embed generated graphs on my own site, instead of using the Wolfram Cloud to host it?
Arguing that the freedom to restrictively licensing your software is more freedom than using GPL because it requires unrestricted future access is analogous to arguing that one should be tolerant of intolerance because that is the more tolerant action.
It's analogous to saying people who murder murderers are murderers. Which is true.
Wait, seriously? So, if someone says "I don't want my kids ever to meet gay people", and I say "I don't want my kids ever to meet that guy", then you feel that I'm more in the wrong?
The first person is ignorant, the second person is annoyed with ignorance. Ignorance isn't the same as being in a minority group. There's no human right to remain ignorant.
Everyone is always ignorant of something, you and I included. Human rights doesn't come into this. It's people pretending to be ignorant of nothing who I'm wary of.
I have a suspicion that we have totally different ways of thinking about this, so our disagreement might be about the axioms rather than their consequences, in which case it's probably useless on both sides for us to argue; but I would like to have one more go, to see if our disagreement is really so fundamental.
Why is it valid to say automatically that someone who is intolerant of homophobia is just doing what society is telling him or her to do? Indeed I'd say to the contrary that there are many societies where homophobia is the normal attitude, so that being intolerant of it is very much going against societal norms.
Even if I'm in a society where homosexuals are (correctly) treated as equals, then describing as simple conformity my revulsion at an attempt to treat them unequally seems to be extremely uncharitable. Why not simply say that I, too, am "being who I am", because of my upbringing or any other reason?
Okay. Let's try that.
Why is it valid to say automatically that someone who is intolerant of homophobia is just doing what society is telling him or her to do? Indeed I'd say to the contrary that there are many societies where homophobia is the normal attitude, so that being intolerant of it is very much going against societal norms.
That's a good question. If we were in such a society, the annoyance I have for people who follows the crowd and do not think for themselves would not apply to you.
Even if I'm in a society where homosexuals are (correctly) treated as equals, then describing as simple conformity my revulsion at an attempt to treat them unequally seems to be extremely uncharitable. Why not simply say that I, too, am "being who I am", because of my upbringing or any other reason?
I have distaste for the intolerant of the intolerant, because on one hand, they know the harm intolerance can cause in society, and on the other, they engage in the very same intolerance they know causes harm, and then they have the gall to tell people they are morally superior. That is knowingly causing harm, and then tricking people into thinking they're tolerating - all it provokes is the very same intolerance in other people, and the very same impulse to disguise this intolerance in others. The intolerant have a passive effect of reducing society's tolerance, which have the consequence of suffering in individuals. The intolerant of the intolerant have the same passive effect, except they're now knowingly partaking in this activity.
The intolerance of the intolerant makes the following situation possible: "Don't talk to that man, he is a misogynist! Oh by the way I hate misogynists. :)". Intolerance in society allows possible situations where simple label will smear the reputation of someone in other's minds for life, before people get to really know who the person is.
And that's the core problem of prejudice, isn't it?
> > Indeed I'd say to the contrary that there are many societies where homophobia is the normal attitude ….
> … If we were in such a society, the annoyance I have for people who follows the crowd and do not think for themselves would not apply to you.
If you are not in such a society, then you live in a happier world, or at least society, than I do—in particular, one where Antonin Scalia is not a Supreme-Court justice.
> I have distaste for the intolerant of the intolerant, because on one hand, they know the harm intolerance can cause in society, and on the other, they engage in the very same intolerance they know causes harm, and then they have the gall to tell people they are morally superior.
I think that certainly there are people who are smug about their intolerance of intolerance, just as there are people who are smug about their intolerance of homosexuality—used as a running example just because it's what I started with, not because I think it's the only kind of intolerance. However, I don't see why it's unfair for me simply to be repulsed by intolerance, without having my repulsion automatically judged to be artificial, and in service of some ulterior motive.
I agree that the fact that I am repulsed by something that (in my opinion, to be sure!) is actually morally bankrupt, as opposed to someone else's by something that is not, doesn't make me a better person; but I don't think that it makes me worse, either. That, and possibly also what seems to be your blanket assumption that intolerance of intolerance can only be in service of some agenda (and not a genuine emotional or intellectual reaction), I think is where we do, and may simply have to agree to continue to, differ.
Tolerance means accepting something is part of your reality, even when you don't like it. If tolerating means accepting something only if you like it, it wouldn't be called tolerance...:)
The fact that it's neither of those would suggest that people don't want it open badly enough. Listing off projects that are open to show that people like open things is absolutely irrelevant.
I think your point is missing the point. The market of people who just want a solution to work and be easy to use is much, much larger than the market that explicitly demands BSD or GPL-style freedom. Wolfram serves the former. Makes more money that way, too.
People don't "like open things" because of marketing hype, they just tend use the most useful things. Collaboration in programming is a feature. If no other projects on github are written in "wolfram language", then learning to program doesn't really enable you to do as much.
That seems a bit like saying that, if people demanded that North Korea were open, then it would be either (a) open or (b) gone. Of course, the lock-in to a software package is less than the lock-in to a country, but at a certain point it is not totally absurd to say that it is effectively impossible to switch.
You're forgetting the third and much more realistic option: that people will come together and create a substitute that far surpasses the original, because of the naturally collaborative nature of free software.
Wolfram the computational engine is a hosted solution, so there's very little point to "opening" that, business continuity reasons aside.
Mathematica I don't know much about, but afaik serious engineers, mathematicians and physicists use MATLAB generally. There's more of a shift to using R and Julia nowadays but academics are notoriously stubborn when it comes to using software, regardless of its quality.
All of those projects which you listed are more or less programming or web-content related - for which the domain knowledge is readily available among the people who enjoy working in open source. One needs domain experts in the particular domain to implement successful software.
Domain experts are motivated by money, peer reputation, and improvement in ones domain. Two of these are readily available in FOSS projects, and becoming a developer in a reputable FOSS project also improves ones career prospects financially quite considerably.
So, for a programmer, participating in a FOSS project is quite appealing.
Now take some other domain, like music. First, if ones peers are likely to be more or less ignorant of software development, they really cannot appreciate the effort an expert places on developing a software. They may find it interesting, but not as admirable as progressing in ones own domain. Secondly, while developing software may give insights in ones problem area, it's not directly related to her craft. Take a hypothetical composer - which is a more appreciated thing, him doing a composition, or testing/speccing some new compositional software. Thirdly, domain experts seldom gain any obvious financial benefit or participating in open source software (I'm talking about the dominating dynamics, not special cases).
Mathematica positions itself as a mathematical appliance, like a fridge or an oven or a car, none of which are generally running free software.
And that is why there are Linux gurus that will invest lots of time to get GNU/Linux run on their fridge - because there are people who will not accept this status quo.
I'm pretty sure the entire FLOSS movement outlines what is meant by software 'freedom' in this context, and why it is important.
And if you don't see the difference between a software "application" and consumer electrical appliances, I'd say you're being willfully ignorant.