I didn't know a lot about bankruptcy before, but I searched around found some information and then finally understood that they had attorneys to help the case.

How to understand the components of the curl formula.

Good description. Hill climbing.

Get the 2 gradients to be parallel. That is the main insight.

Nice article. has insight about "dividing by e^iwt" to see how much is in the original signal.

How much "7" is in 28? 28/7 = 4 sevens.

How much "2Hz" is in x(t)? x(t) / 2Hz. Neat.

What looks like a multiplication is actually a division!

Nice little summary. Covers the essentials.

Recommended, should read.

Need to account for measurement error. Take the midpoint (half before, half after) vs the pure staircase pattern.

Great explanation. Notice the part about introducing new variables.

i and j are defined to be alternate paths to -1 [avoiding regular multiplication]. We can visualize that as another dimension if we like.

ij gives yet a 3rd path [another dimension!]. and (ij)^2 also gets us to -1. But we can't do (i^2 * j^2) because that is -1. So math distributes a little differently. Have to do the inner part (get k), then the outer part.

Hint: that's why vectors are i, j, k => from quaternions! Before we had vector notation. Neat.

I like the description here. Talks about the true essence, not necessarily how it developed.

Core: negative (or complex) probabilities. Whoa! What does that mean?

[Remember, we didn't think negative or complex numbers could exist. Why not probabilities? What metaphor could apply here?]

Notes: mapping probability vectors to each other. Need the sum to still be 1.

The most common mistake done by children is to add the numerators and the denominators separately treating them similar to natural numbers. Once the how many versus how much is well explained, they can then easily grasp why it is necessary to convert the various fractions being added to like fractions (denominator is same) . Multiplication throws up another interesting challenge. When you multiply natural numbers, the result is larger. Multiplying proper fractions gives you a smaller result.

What is important to explain is that they need to compare the resultant (as in size - how much) and see which one is bigger or smaller. When you compare natural numbers, you are comparing how many (count).

Simple way to explain algebra. Understand what 'X' stands for.

Negative numbers represent changes, not amounts. So, a -4 in some unit, let' s say slices of bread, doesn't mean that you have -4 slices, but ratter that you have 4 less slices

You can multiply polynomials and take the coefficient to get the number of combinations / re-arrangements.

(1 + x + x^2) represents the 3 options for taking 0, 1 or 2 of something.

(1 + x) represents 2 options for taking 0 or 1 of something [of x].

(1 + x + x^2)(1+x) = x^3 + 2x^2 + 2x + 1

shows all the possibilities: 1 option for taking all 3, 2 options for taking exactly 2, 2 options for exactly 1, 1 option for exactly 0.

This assumes each "x" is independent. They're not. To count unique orderings, divide each part by k!.

(1 + x + x^2/2!)(1 + x)

Treat x^2/2! as a cohesive "unit". So you might have 3 * x^2/2!, the coefficient is 3 [the 2! is almost part of the x^2, it's how they are arranged.].

Has some interesting arguments, need to investigate further.

This article shows you the most basic usage of ADB to do "things" on your android phone.

Great talk on the difference between simple vs. easy, and how not to "complect" (intertwine) parts of your system.

Really great way to visualize how to handle items like

Draw out the triangle you need [arctan(x) means a triangle with "x" as the height, and we're going to get the angle, and figure out the hypotenuse]. Then you take the cosine (1 / hypotenuse).

Really helps to clear it up!

The visualizations make the topic easier to understand.

Great vid explaining the essence of a tensor -- matching up components with basis vectors.

Rank 0 (scalar) : component, but no basis vectors Rank 1 (vector) : component & 1 basis vector (1 x 3) Rank 2 (array) : component matched with 2 basis vectors. (3x3)

(1 basis vector could be direction of surface, the other is the force applied in the x-direction).

Key useful property (which I need to understand): the combination of components & basis vectors can be agreed-upon by all reference frames (moving, rotating, etc.). What does the "combination" refer to? ("Coordinate-free" -- express relationship between vectors). More on coordinate-free geometry: http://www.cs.brown.edu/~ls/teaching08/LN04_Coordfreegeom.pdf

No absolute coordinates -- you just have a "point" and a vector (with direction and magnitude). But it's not on some grid with x and y components. Coordinates are needed to implement, but not reason about, the coordinate system.

One key to calculus is navigating the different "planes of precision" (i.e. n, n^2, etc.) where one does not effect the other.

How big a constant will make kn a polynomial? It never will. n^2 is a different beast.

Calculus is the art of learning how to manage these different planes.

A(n) => absolutely at most n. A(3) is absolutely at most 3 (<= 3).

O(n) means <= C*n. [for some C which is not specified... we are bordering on infinity now]

Derivative -- when the difference between the successive element

f(x + e) = f(x) + f'(x)e + O(e^2)

Basically, the difference is absolutely at most something * e^2. I.e. we're setting the upper bound on the error there. The error is something * e^2 or less. And as we make e small, e^2 gets even smaller (error margin outruns the change we're making).

Most functions in "practical work" (i.e. the real world) have strong derivatives.

Derivative is the linear approximation term. Ignore the quadratic error term.

Idea to group effects into buckets... what is the 'fuzziness' of each?

f(n) Continuous if the next value is f(x) + o(1)

"it allows us to be sloppy — but in a satisfactorily controlled way"

Nice video about finding e from the derivative definition.

• Find derivative of 2^x (but can't... you get .69 * 2^x)
• Find derivative of 10^x (but you can't... you get 2.3 * 10^x)

Idea is that some number in-between has 1.0 * something^x [and we call that e]

I like how he actually plugged in values (h = 0.00001) when taking the limit to show it's a process you can at least work with, and not keep values abstract.

Quick LISP interpreter in ruby. Key insights:

for the eval method...

• if you're an atomic unit (smallest item), just return it's value from the environment
• most methods have their arguments evaluated first, and then you call the method.

• "if" and "quote" do NOT evaluate their arguments. Pass their arguments through.

  self.eval @env[fn][2], Hash[*(@env[fn][1].zip args).flatten(1)]

Execute the body of the function in a new context

That line above is pretty nuts. Here's how it works

@env[fn] is this:

ruby-1.9.2-p180 :013 > (l.eval :second) => [:lambda, [:x], [:car, [:cdr, :x]]]

so... @env[fn][2] is the body of the function. It's what we want to evaluate.

We need to set an environment with the parameters already wired up.

Hash[*(@env[fn][1].zip args).flatten(1)]

• The outer Hash[] is making a ruby hash for the environment
• @env[fn][1] is the list of parameters [:x]. Putting a .zip makes it an array again [[:x]]
• "zip" matches it up with the args array that was passed in:

ruby-1.9.2-p180 :020 > Hash[*([1, 2].zip [3, 4])] => {[1, 3]=>[2, 4]}

See how 1 => 3 and 2 => 4. The * (splat) operator is needed to turn the array into a list of items / parameters. Finally, the flatten(1) expands it into

{1=>3, 2=>4}

Phew! Lots of ruby magic.

The secret is that :lambda could be anything, actually -- it's just a placeholder really.

Some great insights here (understatement of the millenium):

"If the theory corresponds to the facts, radiation conveys inertia between the emitting and absorbing bodies."

We normally thing "Oh, we transmit energy with radiation" but because of e = mc^2, we can think "Oh, we transmit inertia with radiation", i.e. we are making one item "lighter" and the other more heavy!

Some great insights here:

• Nice explanation of how indexes work: for a given term, store the documents that contain it, along with the position in the doc. To see if a phrase is matched "foo bar" look for both "foo" and "bar" and ensure bar comes right afterwards (nice and fast lookup)
• For regex matches, store trigrams (3-word phrases). Compile a regex query into a search for trigrams. ("Google.*Search => goo AND oog AND ogl AND ...) using the tricks above.

What I've shared with my friends who are not continuing their studies in math (on facebook): (Editor's note: Kalid, I think this would be a great segway if someone were, for example, to do a presentation for schoolkids of today's schools, on making them AWARE of what math actually is in the first place. I actually strongly believe BE, and resources like these, could be extremely powerful in creating a movement among schools all over the world for kids "learning" maths - to inspire them to see the beauty of what math actually IS. Workshops and seminars could be held for that "building awareness" purpose, etc...).

"In summary - math isn't hand calculation, and regurgitation of sterile procedures and notations, as most of us were taught in school. (Surprising, isn't it.) It is something far greater than that. Math is - just like music, painting, dance - an art.

Calculation JUST happens to be of one its practical applications - just like composing a jingle for a TV ad JUST happens to be a practical application of music. We shouldn't treat the MEANS to an end (practical applications) as THE end (the art in its entirety)."

Putting the tree in this format really makes it click. The site has an example audio file going through the alphabet too. Great example of how to present an idea.

I come across betterexplained while searching about some server gzip compression. and i loved the way topics are explained. After that i come accross with aha.betterexplained . then i thought of creating some thing similar. Now i created some thing smilar. Ie http://slugs.in/

This is SUCH an interesting topic, that I decided to include a Google search link as opposed to an article.

Being a lefty and right-brain dominant, it's very interesting to note that school systems of today are most advantageous to the majority - left-brained people: -Strict timetabling -Emphasis on writing step-by-step procedure -Details over big picture -RIGOR AT THE NEGLECT OF INTUITION

However, BE is so wonderful for the more creative right-brained thinkers - providing the big picture, the intuition, the visual metaphors, etc...

Kalid, I'm very curious to hear your take on this "right brain vs left brain" matter - and perhaps look forward to an article being written about this very fascinating topic!

Thus, why it is important to "simplify".

Please also watch the video in the included link within the webpage.

It's amazing to fathom the size of the universe from the visual imagery! We are a mere, infinitesimally small speck...

A very different perspective than what one would be commonly "taught" in today's schools. From a wonderful blog.

Cont'd next post:

A take on why it is perhaps better to develop critical thinking skills in the work-force, in today's bustling 21th century world.

A wonderful video produced by Carl Sagan, which explains the 4th dimension.

He simplifies the analogy by demonstrating 2d beings, imagining an "inconceivable" third dimension. As humans, we are simply 3d beings who cannot "conceive" that 4th dimension.

Breaks down the need for a Fourier transform... you have an element (a fly) which can be measured in 2d, 3d, any number of dimensions.

The magnitude of each dimension (in 8-D, let's say) lets you reconstruct the position of the fly.

The link shows how a function made up of sin*cos as basis vectors will be 0 (orthogonal). For continuous functions you do an integral for the dot product.

I also like the "How to remember without really trying." If you are trying to remember it means you didn't get an intuitive understanding of it!

Good writeup on how to structure a class. Things I like:

• Homework is 1/3 current, 1/3 last week, 1/3 anywhere in the course (increasing difficulty). Let's not pretend we can just forget the past!

• Asking people questions very regularly (getting students engaged)

• Making it so there's no need to review for the final! You've been really learning through the course so there's no last-minute cramming! (Imagine "last-minute cramming to learn how to walk"). The fact that cramming works at all, for any course, is a sign we aren't learning!

"If you don't feel like reading it, the most important take-away for web programmers is the Single Point of Truth Rule, that is, "every piece of knowledge must have a single, unambiguous, authoritative representation within a system". If you design a system that violates this rule, you are setting yourself up for endless headaches and disasters."

I like these deep fundamental insights about how to design systems.

I like that it starts with what we are trying to do and how it works, and THEN getting into the corner cases (What makes a nice grammar?).

For these tutorials, esp. for parsers where there are so many ways to handle them, let's figure out how to discuss the fundamental issues (without getting mired in specifics, LL/LALR/LALAL :) ).

Also: Not Quite LL(1) grammar for javascript:

http://hepunx.rl.ac.uk/~adye/jsspec11/llr.htm

Also see:

http://progzoo.net/wiki/Recursive_Descent_Parser_Tutorial

Gotcha... you need to peek at the next input (Read the next token and put it back) for one of the examples!

Some clear, no-nonsense description of abstractions without crazy analogies.

"You can thus write instructions for doing stuff to entire trees very concisely: to snuggle a whole tree, first snuggle the base of the tree, then snuggle each branch as though it were a whole tree."

"This works in less silly examples as well: to sort people by height, move all the shorter-than-average people to the left, and all the taller-than-average people to the right, then sort each side. Bam. You’ve just invented quicksort."

Key insight:

• Measure variation A and variation B
• You are getting samples of both. So you have error bars. A has p(a) with some error (standard error, based on number of trials). B has p(b) with same standard error.
• Take a bunch of measurements. Figure out their error bars (at 95% confidence interval).

A is better than B if the error bars don't overlap, i.e.

A: 9 +/- 1% B: 6.5 +/- 1.5%

The best B can be is 8 (6.5 + 1.5), but the worst A can be is 8 (9 - 1) so A is the better choice.

Key insight: Look for the overlap in error bars.

Examples

InstaCalc example

Note how as your p goes down (1% vs 10%) the absolute error drops, but the ratio of absolute error to your amount goes up! So at p = 1%, SE = .0025 but SE is 25% of your measurement!

When your p = 10%, SE = .0077 (three times greater), but your SE is only 7% of your measurement!

Example from a blog comment

"Control: SQRT(0.1 * (1-0.1) / 1000)= 0.00949 SE = 0.00949 * 1.96 = 0.0186 thus 10% ± 1.9% = 8.1% to 11.9%

Variation: SQRT(0.15 * (1-0.15) / 1000)= 0.01129 SE = 0.01129 * 1.96 = 0.02213 thus 15% ± 2.2% = 12.8% to 17.2%

Thus, since there is no overlap, the variation results are reliable."

I like how this is arranged, it communicates the different pieces of git and how they interact. One key to git is realizing how files can live in different parts (the index, local workspace ,etc.) and how to move them around.

Key insight: the purpose of squaring, summing, and square rooting is not to "make the sign positive" but to "punish outliers". The further away (larger the number), the higher your square.

"Real mathematics is (or at least should be) algorithmic. The axiomatic method is like machine language or a Turing machine or a Tuxedo. It is very stifling. The logicist approach that takes several hundred of pages to prove that 1+1=2 is ridiculous. Let's be happy with the current standards of rigor in informal human mathematical discourse, and use computers with that level. If anything, we have to be flexible, and relax the rigor, allowing semi-rigorous proofs, and even non-rigorous proofs (as long as we state from the outset the level of rigor).

So let's leave this formal proof game to professional computational logicians, but regular mathematicians, like Tom Hales used to be before he let his human critics push him around, should be pragmatic and try to optimize computers' great potential. Absolute certainty is impossible, so let's settle with the same, or even diminished, level of "rigor" that we are used to in normal mathematical discourse. Only this way would we have a reasonable chance to see a proof of RH, Goldbach, 3x+1, P vs. NP, etc. in our lifetime. "

Nice summary:

Less Important Guessing factors for polynomials Knowing many tricks for integration Being careful when copying over expressions many times Finding roots of complex equations Knowing how to do matrix row operations Knowing how to avoid dropping minus signs Memorizing specific rules for derivatives of such functions as tangent and secant Memorizing multiple angle formulas for trig functions

More Important Translating statements about problems in natural language into statements in mathematical or procedural language Learning how to experiment with math Knowing which integrals should best be done numerically Knowing how to work backwards or to use numerical methods to check symbolic results for plausibility Knowing how to use techniques from programming Understanding recursion and how to use it practically Knowing which functions are discontinuous and where they are discontinuous Knowing how to mix math and programming

Key insight is to see the overlap between having the event and having a positive test.

A venn diagram is a great way to see that. What is the ratio of the overlap to each side?

Another visualization:

http://makematics.com/syllabus/2012-fall/

"Turn information about cause->effect into effect -> likely cause."