They also have Mastering Dyalog APL by Bernard Legrand as a free PDF download. I've just starting reading it, seems to be a very gentle introduction to APL: http://www.dyalog.com/mastering-dyalog-apl.htm
The inline threaded comments look like an awesome feature, would be amazing to have an inline widget like that in Code Mirror. Submitting tiny local patches this way might be useful, too :D
Not being a native speaker I had to google for it but it seems the correct usage is "hear, hear"[1]. (Just pointing it out in case other people are in a similar situation as me).
I'm pretty much at the other end of the spectrum. For the time being I would probably discontinue my contribution if one of the developers I am tipping decides to do something I don't approve of (say, join Oracle). However, that's not my ideal long-term situation:
Ideally, I would, over time, decide for myself that I actually put total trust into people I support, that I trust them to do the right thing and continue to do so. To continue to make the right decisions, even if I may not understand their every reasons, even if I am actually opposed to a particular move.
Basically, I want to help „setting them free“. This concept exists for entrepreneurs in the form of „FU money“ but I would like see something like that to happen elsewhere, be it OSS developers, political activists or philosophers, caring mothers or fathers, teachers, artists, or musicians. I think crowd-founding makes possible which I could never achieve from the income I generate alone.
So eventually I'd like to decide (in some cases) to make my commitment irrevocable, if that would be by contract alone or by putting 500 weeks of tips into a safe fund, I don't know but I think independent of whether gittip is going to have a feature like that eventually I think this is an important step into the right direction, namely not expecting anything in return for the absolute trust I give out :-)
(I really like the idea of fully generalized reciprocity, i.e. all give not because they receive something in return but because they know enough people are giving, too. I'm not naive enough to think everybody will take part in such a scheme but I think these OSS developers show how much impact even freeing some of them could make).
(I absolutely agree on your other post, many will be suspecious of and reject no-strings-attached donations, I have no problems with that at all)
I really love that idea. I think a lot of students which are bored by school (and/or feel left behind) would regain their natural curiosity in such an environment. I think the technical possibilities we have now make much more individual approaches to learning possible and computers can help with this cross-subject approach.
Based on your example they could then go on to construct some instrument (say, a flute) by writing a little program and print the instrument with a 3d printer or have a rough version cut by a laser cutter. The question is: how to integrate ideas like that in the current school system? ...
I'm dreaming of a curriculum where students start to program their own computer algebra system in 9th grade (or earlier), say, using Python or Clojure. Starting by teaching it to solve simple equations for x, then proceed over the next 4 years by extending it to know about binomial formulas, solving quadratic euations, perform gaussian elimination, symbolic differentiation and integration, etc. I guess the world isn't ready for that idea, yet ;)
I've taken an introduction to statistics course with social science students and based on that experience, I can relate to what you are saying, 100%.
However, I think there is a broad group of students[1] for which a significantly earlier exposure to calculus would be beneficial and make learning statistics (and physics) a lot easier or at least faster.
When I took introduction to statistics as a math major, I found the subject extremely confusing because the discrete and continuous case where taught completely disconnected and useful anchors for understanding such as basic measure theory and Lebesgue integration where left out. That's certainly a good way to teach for many but for some it doesn't work.
A similar case was physics for me (classical mechanics in particular). From grade 5 to 10 (after which I avoided the subject) there was little insight gained (e.g. heavy things fall down, there may be some friction, memorize all those seemingly random formulas and if you use a long lever, make sure you pick a strong material). Then I was exposed to an introduction to physics course at university (for non-majors) and the revelation that all those random formulas have a strong grounding in just 3 general principles and can then be developed with some help from calculus was liberating. Just too late in my case. Maybe I would have loved physics and actually study it, had they told me in 7th grade that there is something tying all of it together, and the ultimate goal of the class was to reach that summit. Just trying to show the other side of the coin which should be integrated into the way math and science is taught in schools in my opinion :-)
Searching a little I found this interesting document addressing some of the problems which I have put on my reading list: "The Science of Thinking, and Science for Thinking: A Description of Cognitive Acceleration through Science Education (CASE)" (Philip Adey, 1999).
Assuming the idea of a "formal operational" stage of development applies, the situation looks abysmal (at least in the US and Germany, can't say much about other countries):
From the little I gathered so far (on the internet, so it has to be taken with a grain of salt) it seems that (1) a vast majority (over 60%) of people never reach formal operational maturity. (2) Ideas of how teaching can actually help with it are in it's infancy. (3) Application of said ideas is not very far along. (4) Educational systems keep leaving many (or most) students behind early, especially in math and science, while other students get bored and waste their time in class, being taught a mind-choking curriculum.
Ok, I guess I'm ranting now :-) Saddens me greatly, though.
I think a lot of everyday reuse (by factoring commonly used code) happens at a level of programming which neither fits application nor library development but writing small tools to automate ad-hoc tasks (e.g. by scientists, admins, etc.) Environments like Python, the shell, or Lisps seem to be more suited to this kind of development than, say, Java.
In the case of the example, I could easily imagine that the "isolate words in input text"-part will turn out to show up again, and then one would factor it out to a function. When the first text containing unicode soft hyphen characters is encountered, only a single shared function has to be updated, and all little scripts using it will benefit!
A function extracting the text from xml-documents, skipping a configurable set of element types, might find similar reuse, etc.
Just an aside: I'm not familiar with Python, what I found disappointing was the mix of chained object method invocations and "outer" function calls - since replacing the built-in string class seems to be frowned upon, I was wondering how the example script would look like using pipe[1] :-)
One question about the Python code: is the first call to sorted needed, and if yes, why?
I like your explanation of this feature. I guess it rarely works for me because I open dozens of tabs when I start and some of them inevitably become stale if I do something else in between and then go back to read some hacker news discussion.
I often and up just closing discussions having a "more"-link since it tends to frustrate me one way or another. I wish there was an option to disable "more"-links entirely (or is there?) I can see how it's useful for small screens but full-size on a 27"+ screen or in portrait mode (my preference for browsing the web) I think seeing 500+ comments on one page would be totally fine :-)
(Ideally, after reloading it, new submissions would be highlighted, one can only dream)
I don't really know where they get their data and the overall picture might well be right but e.g. the rent index within Germany is quite dubious: In their list, Frankfurt and Cologne have a lower rent index than Berlin, whereas I think the map on immobilienscout24 looks a lot more believable[1]
I don't have original or better data but let's carefully say that from the anecdotes that reach me it would be useful to study what rent you would have to pay realistically (for an apartment and for office space) as a non-local coming to a given city. Specifically, as a start-up founder or engineer, you would most likely not want to live in the cheapest neighborhood, independent of if it's New York, Sofia, Warsaw, or Berlin.
tl;dr Most eastern European capitols might be a lot cheaper than Berlin but the linked data should not be trusted blindly.
Good point. Maybe that's the reason why it's not found by search, too. I think claiming the app's name was "Timer" when in fact it is called "Timer :"[1] is dubious. Ok, maybe the app stores search should prioritize highly rated apps but it seems there are simply a large number of apps having "Timer" in their names.
(Besides, relying on the app store as such for marketing is a gamble, that should be established by now ...)
[1] how did the author come up with "Timer :", it's just weird, I think.
I'm just reading the book Flow-Based Programming (2nd Edition) by Paul Morrison[1].
I would say the main idea is to shift focus from control-flow to how data ("information packets") flow through a network of (black box) components and only use traditional control-flow style programming for the most simple, atomic components. The book presents some convincing examples from business programming but I think the idea should work very well for other areas than text processing, certainly for image manipulation or sound processing.
The split between component creators and component assemblers (application programmers) is highlighted in the book, I hate it how often I tend to slip from one role to the other in regular programming, maybe such an explicit split would help a lot (well, or certainly a lot of experience will ...)
The instruction set page linked in the article mentions: To move a double quadword to or from memory locations that are known to be aligned on 16-byte boundaries, use the MOVDQA instruction - would it not be beneficial to use this instruction for most of the memory to be copied and only use the slower variants for the leading and trailing bytes?
Does the C semantics prevent the compiler from issuing a run-time check for the (rare) aliasing case and proceed with the fast version in the common case? (probably unrolled, too?)
Out of curiosity: The code uses a special counter variable count which has to be decremented separately - is this faster than testing for dst != behind_last_dst_prt ?
(aside: my gut-feeling tells me that if the combination of C/8086 can't pull his example of at the maximum memory to processor transfer speed for sufficiently large input vectors, there is something seriously rotten ...)
A mapping of a 3 dimensional space to a 2 dimensional space will bring some points (colors) too close together, this happens with the missing color cones. So now the driver tries to correct this by changing the mapping from 3d to 2d color space, in order to move green and red (for example) apart in the eye of the color blind person. The likelihood that this mapping will bring together other colors, which before were meaningfully apart, is high.
The mapping could work like high dynamic range mappings, trying to take into account local image features but this would probably make everything look really garish :(
I agree that a switch/mode in those color-modifying lense programs could be to remap color channels so a color blind person trying to read a specific chart or website could temporarily remap colors in order to better tell apart the colors used.
edit: disclaimer: I don't know about anybody with limited color vision personally so I just try to be careful assuming the problem could be solved easily. If testing with actual people with this condition proves me wrong, great.
I don't think it's as easy as you make it sound. The hypothetical driver would need to map everythink produced for "standard" trichromatic vision "down" to dichromatic vision in a meaningful way, maintaining contrast where it is relevant, but how should the driver know? (Maybe I am overestimating the technical challenge, so please correct me if I am wrong)
I think the solution can only be to make sure semantically relevant differences in color (e.g. different positions in a chart) can be identified by people with dichromatic vision, e.g. by not using the popular disticton of light red vs. light green. Quickly viewing a design through one of those filter programs is no big tasks and should be part of basic accessibility checks.
This doesn't mean you can't use all kinds of colors when they are not relevant to understanding, [edit: removed direct reference to deleted parent content]
A nice addition to my slime/Emacs environment (which is really a rediscovery for me after almost 10 years in IDEs like Eclipse) was iimage[1]. It converts image file name in the REPL to inline images, makes it very easy to prototype functions that create some graphics. E.g. I use vecto[2] (also written by Zach!) to produce a disk usage visualization and it shows up directly below the function call in Emacs :D