This determines how much precision the GPU uses when calculating floats. `highp` is high precision, and of course more intensive than `mediump` (medium precision) and `lowp` (low precision).  

Some systems do not support `highp` at all, which will cause code not to work at all on those systems.

On systems that DO support `highp`, you will see a performance hit, and should use `mediump` and `lowp` wherever possible. A good rule of thumb that I saw was:    
- `highp` for vertex positions,    
- `mediump` for texture coordinates,   
- `lowp` for colors.

Hope that helps!

I cannot perform an on-the-fly logging fileHandle change.

For example, I have 3 classes

`one.py`

    import logging
    class One():
        def __init__(self,txt=&quot;?&quot;):
            logging.debug(&quot;Hey, I&#39;m the class One and I say: %s&quot; % txt)

`two.py`

    import logging
    class Two():
        def __init__(self,txt=&quot;?&quot;):
            logging.debug(&quot;Hey, I&#39;m the class Two and I say: %s&quot; % txt)


`config.py`

    import logging
    class Config():
        def __init__(self,logfile=None):
            logging.debug(&quot;Reading config&quot;)
            self.logfile(logfile)

`myapp`

    from one import One
    from two import Two
    from config import Config
    import logging

    #Set default logging
    logging.basicConfig( 
        level=logging.getLevelName(DEBUG), 
        format=&#39;%(asctime)s - %(name)s - %(levelname)s - %(message)s&#39;,
        filename=None
    )

    logging.info(&quot;Starting with stdout&quot;)

    o=One(txt=&quot;STDOUT&quot;)
    c=Config(logfile=&quot;/tmp/logfile&quot;)

    # Here must be the code that change the logging configuration and set the filehandler

    t=One(txt=&quot;This must be on the file, not STDOUT&quot;)
    

If I try `loggin.basicConfig()` again, it doesn&#39;t work.


How to change filehandle with Python logging on the fly with different classes and imports

What I want to do is change the size of an UICollectionViewCell, and to animate that change, when the cell is selected. I already managed to do that unanimated by marking a cell as selected in `collectionView: didSelectItemAtIndexPath:` and then calling `reloadData` on my UICollectionView, displaying the selected cell with a different size.

Nevertheless, this happens all at once, and I have no clue how to get that change in size animated. Any ideas?

I already found [https://stackoverflow.com/questions/12885003/animate-uicollectionview-cells-on-selection](https://stackoverflow.com/questions/12885003/animate-uicollectionview-cells-on-selection), but the answer was to unspecific for me and I didn&#39;t figure out yet if it could also help me in my case.

UICollectionView: Animate cell size change on selection

In the [learningwebgl tutorial1](http://learningwebgl.com/blog/?p=28) I&#39;ve found an interesting line in the fragment shader.

    precision mediump float;


I&#39;ve found an article about it [here](http://updates.html5rocks.com/2011/12/Use-mediump-precision-in-WebGL-when-possible), but I still can&#39;t understand what does it mean?

And if I remove this line, nothing changes. Everything is the same.
So what does `precision mediump float` mean?

What does `precision mediump float` mean?

In the <a href="http://learningwebgl.com/blog/?p=28" target="_blank" rel="noopener noreferrer">learningwebgl tutorial1</a> I've found an interesting line in the fragment shader.
<pre><code class="hljs language-sql">precision mediump float;
</code></pre>
I've found an article about it <a href="http://updates.html5rocks.com/2011/12/Use-mediump-precision-in-WebGL-when-possible" target="_blank" rel="noopener noreferrer">here</a>, but I still can't understand what does it mean?
And if I remove this line, nothing changes. Everything is the same.
So what does <code>precision mediump float</code> mean?

&gt; **Possible Duplicate:**  
&gt; [Length of Javascript Object (ie. Associative Array)](https://stackoverflow.com/questions/5223/length-of-javascript-object-ie-associative-array)  

&lt;!-- End of automatically inserted text --&gt;

I have an object similar to this one:

    var jsonArray = {
      &#39;-1&#39;: {
        &#39;-1&#39;: &#39;b&#39;,
        &#39;2&#39;: &#39;a&#39;,
        &#39;10&#39;: &#39;c&#39;
      },
      &#39;2&#39;: {
        &#39;-1&#39;: &#39;a&#39;,
        &#39;2&#39;: &#39;b&#39;,
        &#39;10&#39;: &#39;a&#39;
      },
      &#39;5&#39;: {
        &#39;-1&#39;: &#39;a&#39;,
        &#39;2&#39;: &#39;a&#39;,
        &#39;10&#39;: &#39;b&#39;
      }
    };

I&#39;m trying to get it&#39;s length, the problem is that `jsonArray.length` returns 5 instead of 3 (which is the total items it has). The array is relatively long (has 1000x2000 items) and this must be done a lot of times every second. How can I get the number of items more efficiently?

Get total number of items on Json object?

I asked [a question][1] on how to plot dynamically according to user interactions, whose solution
works quite well on my machine. 

Now I want to make an on-line version and host it with [Shiny][2]. 

I have tried to put the code into `server.R` and invoke the `iden()` function inside `reactivePlot()`, but the part of `identify()` does not take effect. 

So, any hints on this task?


  [1]: https://stackoverflow.com/q/13714724/688080
  [2]: http://shiny.rstudio.org/

Use D3 and Shiny to implement `identify()` in R

Is there an easier way to copy a folder and all its content without manually doing a sequence of `fs.readir`, `fs.readfile`, `fs.writefile` recursively?

I am just wondering if I&#39;m missing a function which would ideally work like this:

    fs.copy(&quot;/path/to/source/folder&quot;, &quot;/path/to/destination/folder&quot;);


Copy folder recursively in Node.js

In my index.ejs I have this code:

    var current_user = &lt;%= user %&gt;

In my node I have


    app.get(&quot;/&quot;, function(req, res){
        res.locals.user = req.user
        res.render(&quot;index&quot;)
    })

However, on the page I obtain


    var current_user = [object Object]

and if I write 

    var current_user = &lt;%= JSON.stringify(user) %&gt;

I obtain:

    var current_user = {&amp;quot;__v&amp;quot;:0,&amp;quot;_id&amp;quot;:&amp;quot;50bc01938f164ee80b000001&amp;quot;,&amp;quot;agents&amp;quot;:...


Is there a way to pass a JSON that will be **JS readable**?

Express and ejs &lt;%= to render a JSON

Why would someone prefer either the [Lodash][1] or [Underscore.js][2] utility library over the other?

Lodash seems to be a drop-in replacement for underscore, the latter having been around longer.

I think both are brilliant, but I do not know enough about how they work to make an educated comparison, and I would like to know more about the differences.

  [1]: http://lodash.com/
  [2]: http://underscorejs.org/




Differences between Lodash and Underscore.js

I am working on an opengl project. 
I have used some images (2 for x-y scales) and labels (8) to display the scale on the screen. 
My first view is a `tableview` from which I go to `openglView`. But whenever I go back from `openglView` to the `tableView` it gives me this error and app crashes. 

**&quot;This UIView seems to be the delegate of an NSISVariable it doesn&#39;t know anything about. This is an internal UIKit bug.&quot;**

ANY Suggestions?
Is this happening because I am including too many UI elements, other than those images and labels I have used some buttons also. And I am applying `affineTransform` to those images and labels and one button also.


**Exact error is:**

    2013-01-31 12:20:18.743 EMtouch[50496:12203] *** Terminating app due to uncaught exception &#39;NSInternalInconsistencyException&#39;, reason: &#39;{ Rows:
    	UILayoutContainerView:0x9835660.Height == 480 + 1*0x7e53030.marker + 1*0x7e546c0.marker
    	UILayoutContainerView:0x9835660.Width == 320 + 1*0x7e52f90.marker + 1*0x7e54330.marker
    	UILayoutContainerView:0x9835660.minX == 0 + 1*0x7e52ca0.marker + -0.5*0x7e52f90.marker
    	UILayoutContainerView:0x9835660.minY == 0 + 1*0x7e52fd0.marker + -0.5*0x7e53030.marker
    	UINavigationTransitionView:0x9837ea0.Height == 480 + 1*0x7e51bf0.marker + 1*0x7e53030.marker + 1*0x7e546c0.marker
    	UINavigationTransitionView:0x9837ea0.Width == 320 + 1*0x7e519c0.marker + 1*0x7e52f90.marker + 1*0x7e54330.marker
    	UINavigationTransitionView:0x9837ea0.minX == 0 + 1*0x7e51940.marker + -0.5*0x7e519c0.marker
    	UINavigationTransitionView:0x9837ea0.minY == 0 + 1*0x7e51b80.marker + -0.5*0x7e51bf0.marker
    	UIWindow:0x7e1aea0.Height == 480 + 1*0x7e546c0.marker
    	UIWindow:0x7e1aea0.Width == 320 + 1*0x7e54330.marker
    	UIWindow:0x7e1aea0.minX == 0 + -0.5*0x7e54330.marker + 1*0x7e54410.marker
    	UIWindow:0x7e1aea0.minY == 0 + 1*0x7e542d0.marker + -0.5*0x7e546c0.marker
    	objective == &lt;250:-0.000579834&gt; + &lt;250:-9.72015e-08&gt;*UILabel:0x7b44bf0.Width + &lt;250:9.72015e-08&gt;*UILabel:0x7b45100.Width
    
      Constraints:
    	&lt;NSAutoresizingMaskLayoutConstraint:0x7e51940 h=-&amp;- v=-&amp;- UINavigationTransitionView:0x9837ea0.midX == UILayoutContainerView:0x9835660.midX&gt;		Marker:0x7e51940.marker
    	&lt;NSAutoresizingMaskLayoutConstraint:0x7e519c0 h=-&amp;- v=-&amp;- UINavigationTransitionView:0x9837ea0.width == UILayoutContainerView:0x9835660.width&gt;		Marker:0x7e519c0.marker
    	&lt;NSAutoresizingMaskLayoutConstraint:0x7e51b80 h=-&amp;- v=-&amp;- UINavigationTransitionView:0x9837ea0.midY == UILayoutContainerView:0x9835660.midY&gt;		Marker:0x7e51b80.marker
    	&lt;NSAutoresizingMaskLayoutConstraint:0x7e51bf0 h=-&amp;- v=-&amp;- UINavigationTransitionView:0x9837ea0.height == UILayoutContainerView:0x9835660.height&gt;		Marker:0x7e51bf0.marker
    	&lt;NSAutoresizingMaskLayoutConstraint:0x7e52ca0 h=-&amp;- v=-&amp;- UILayoutContainerView:0x9835660.midX == UIWindow:0x7e1aea0.midX&gt;		Marker:0x7e52ca0.marker
    	&lt;NSAutoresizingMaskLayoutConstraint:0x7e52f90 h=-&amp;- v=-&amp;- UILayoutContainerView:0x9835660.width == UIWindow:0x7e1aea0.width&gt;		Marker:0x7e52f90.marker
    	&lt;NSAutoresizingMaskLayoutConstraint:0x7e52fd0 h=-&amp;- v=-&amp;- UILayoutContainerView:0x9835660.midY == UIWindow:0x7e1aea0.midY&gt;		Marker:0x7e52fd0.marker
    	&lt;NSAutoresizingMaskLayoutConstraint:0x7e53030 h=-&amp;- v=-&amp;- UILayoutContainerView:0x9835660.height == UIWindow:0x7e1aea0.height&gt;		Marker:0x7e53030.marker
    	&lt;NSAutoresizingMaskLayoutConstraint:0x7e54330 h=--- v=--- H:[UIWindow:0x7e1aea0(320)]&gt;		Marker:0x7e54330.marker
    	&lt;NSAutoresizingMaskLayoutConstraint:0x7e546c0 h=--- v=--- V:[UIWindow:0x7e1aea0(480)]&gt;		Marker:0x7e546c0.marker
    	&lt;_UIWindowAnchoringConstraint:0x7e542d0 h=--- v=--- UIWindow:0x7e1aea0.midY == + 240&gt;		Marker:0x7e542d0.marker
    	&lt;_UIWindowAnchoringConstraint:0x7e54410 h=--- v=--- UIWindow:0x7e1aea0.midX == + 160&gt;		Marker:0x7e54410.marker
    }: internal error.  Cannot find an outgoing row head for incoming head UILabel:0x7b44bf0.Width, which should never happen.&#39;
    *** First throw call stack:
    (0x1fb1012 0x19f4e7e 0x1fb0deb 0x1599609 0x159c64f 0x159c753 0xe7e8f9 0x982b24 0x982783 0xbba3fe 0xbba698 0x97a3b6 0x97a554 0x28f7d8 0x1c2b014 0x1c1b7d5 0x1f57af5 0x1f56f44 0x1f56e1b 0x34d37e3 0x34d3668 0x93c65c 0xc56d 0x2b35 0x1)
    libc++abi.dylib: terminate called throwing an exception



&quot;This UIView seems to be the delegate of an NSISVariable it doesn&#39;t know anything about. This is an internal UIKit bug&quot; Error

I have the following ColorMatrixFilter. But I want to use it as a mask for Subtract-Blend mode, instead of using it directly. How do I go about achieving this? 

ColorMatrix: 

    colorMatrix[
			0.393, 0.7689999, 0.18899999, 0, 0,
			0.349, 0.6859999, 0.16799999, 0, 0,
			0.272, 0.5339999, 0.13099999, 0, 0,
			0,     0,         0,          1, 0
		];


Subtract Blend Mode using ColorMatrixFilter in Android?

I am learning WebGL these days, but I found that it&#39;s really hard to understand the pipeline.

1. Is there any **head first** WebGL tutorial online ? 
2. Should I learn GLSL ?
3. The code to draw something with WebGL is too complex, is there any way to reduce the code lines?

How do I learn WebGL the fast way?

I have been working on an area lighting implementation in WebGL similar to this demo:

http://threejs.org/examples/webgldeferred_arealights.html

The above implementation in three.js was ported from the work of ArKano22 over on gamedev.net:

http://www.gamedev.net/topic/552315-glsl-area-light-implementation/

Though these solutions are very impressive, they both have a few limitations. The primary issue with ArKano22&#39;s original implementation is that the calculation of the diffuse term does not account for surface normals.

I have been augmenting this solution for some weeks now, working with the improvements by redPlant to address this problem. Currently I have normal calculations incorporated into the solution, BUT the result is also flawed.

Here is a sneak preview of my current implementation:

![area lighting teaser][1]

## Introduction

The steps for calculating the diffuse term for each fragment is as follows:

1. Project the vertex onto the plane that the area light sits on, so that the projected vector is coincident with the light&#39;s normal/direction.
2. Check that the vertex is on the correct side of the area light plane by comparing the projection vector with the light&#39;s normal.
3. Calculate the 2D offset of this projected point on the plane from the light&#39;s center/position.
4. Clamp this 2D offset vector so that it sits inside the light&#39;s area (defined by its width and height).
5. Derive the 3D world position of the projected and clamped 2D point. This is the **nearest point** on the area light to the vertex.
6. Perform the usual diffuse calculations that you would for a point light by taking the dot product between the the vertex-to-nearest-point vector (normalised) and the vertex normal.

## Problem

The issue with this solution is that the lighting calculations are done from the **nearest point** and do not account for other points on the lights surface that could be illuminating the fragment even more so. Let me try and explain why…

Consider the following diagram:

![problematic area lighting situation][2]

The area light is both perpendicular to the surface and intersects it. Each of the fragments on the surface will always return a **nearest point** on the area light where the surface and the light intersect. Since the surface normal and the vertex-to-light vectors are always perpendicular, the dot product between them is zero. Subsequently, the calculation of the diffuse contribution is zero despite there being a large area of light looming over the surface.

## Potential Solution

I propose that rather than calculate the light from the **nearest point** on the area light, we calculate it from a point on the area light that yields the greatest dot product between the vertex-to-light vector (normalised) and the vertex normal. In the diagram above, this would be the purple dot, rather than the blue dot.

## Help!

And so, this is where I need your help. In my head, I have a pretty good idea of how this point can be derived, but don&#39;t have the mathematical competence to arrive at the solution.

Currently I have the following information available in my fragment shader:

* vertex position
* vertex normal (unit vector)
* light position, width and height
* light normal (unit vector)
* light right (unit vector)
* light up (unit vector)
* projected point from the vertex onto the lights plane (3D)
* projected point offset from the lights center (2D)
* clamped offset (2D)
* world position of this clamped offset – the **nearest point** (3D)

To put all this information into a visual context, I created this diagram (hope it helps):

![available lighting information][3]

To test my proposal, I need the **casting point** on the area light – represented by the red dots, so that I can perform the dot product between the vertex-to-casting-point (normalised) and the vertex normal. Again, this should yield the maximum possible contribution value.

# UPDATE!!!

I have created an interactive sketch over on CodePen that visualises the mathematics that I currently have implemented:

## http://codepen.io/wagerfield/pen/ywqCp

![codepen][4]

The relavent code that you should focus on is line **318**.

`castingPoint.location` is an instance of `THREE.Vector3` and is the missing piece of the puzzle. You should also notice that there are 2 values at the lower left of the sketch – these are dynamically updated to display the dot product between the relevant vectors.

I imagine that the solution would require another pseudo plane that aligns with the direction of the vertex normal AND is perpendicular to the light&#39;s plane, but I could be wrong!


  [1]: http://i.stack.imgur.com/4V5c0.png
  [2]: http://i.stack.imgur.com/ubZ4v.png
  [3]: http://i.stack.imgur.com/pZUEf.png
  [4]: http://i.stack.imgur.com/USld4.png

Improved Area Lighting in WebGL &amp; ThreeJS

Is there an analogy that I can think of when comparing these different types, or how these things work?

Also, what does uniforming a matrix mean?

In WebGL what are the differences between an attribute, a uniform, and a varying variable?

I&#39;ve been knocking around Shadertoy - https://www.shadertoy.com/ - recently, in an effort to learn more about OpenGL and GLSL in particular. 

From what I understand so far, the OpenGL user first has to prepare all the geometry to be used and configure the OpenGL server (number of lights allowed, texture storage, etc). Once that&#39;s done, the user then has to provide at least one vertex shader program, and one fragment shader program before an OpenGL program compiles.

However, when I look at the code samples on Shadertoy, I only ever see one shader program, and most of the geometry used appears to be written directly into the GLSL code.

How does that work?

My guess is that a vertex shader is already prepared upfront, and that the editable/sample shader is only a fragment shader. But then that doesn&#39;t explain the geometry in some of the more complex examples...

Can anyone explain how Shadertoy works?



WebGL/GLSL - How does a ShaderToy work?

Is there any reason, except performance, for using WebGL instead of 2D-Canvas for **2D** games/apps?

In other word what 2D functionalities are offered by WebGL which are not possible to achieve easily with 2D-Canvas?

Is there any reason for using WebGL instead of 2D Canvas for 2D games/apps?

I&#39;m curious why GitHub calls submissions to merge, &quot;Pull requests.&quot;

From my understanding, `git pull` will pull all changes, from a remote repository, into a current working branch.  Then merge those changes with `FETCH_HEAD`. ([Git Pull][1])

So taking a look at `git push`... a push would actually push committed changes to a repository.  And isn&#39;t that what you are doing with a Git repo?  Submitting a &quot;request&quot; to merge your code? So why isn&#39;t it called a &quot;Push request&quot;?

  [1]: http://www.kernel.org/pub/software/scm/git/docs/git-pull.html

Why does GitHub call foreign submissions, a &quot;Pull Request&quot;?

Consider a single-linked list. It looks something like

    data List x = Node x (List x) | End

It is natural to define a folding function such as

    reduce :: (x -&gt; y -&gt; y) -&gt; y -&gt; List x -&gt; y

In a sense, `reduce f x0` replaces every `Node` with `f` and every `End` with `x0`. This is what the Prelude refers to as a _fold_.

Now consider a simple binary tree:

    data Tree x = Leaf x | Branch (Tree x) (Tree x)

It is similarly natural to define a function such as

    reduce :: (y -&gt; y -&gt; y) -&gt; (x -&gt; y) -&gt; Tree x -&gt; y

Notice that _this_ reduction has a quite different character; whereas the list-based one is inherently sequential, this new tree-based one has more of a divide-and-conquer feel to it. You could even imagine throwing a few `par` combinators in there. (Where would you put such a thing in the list version?)

My question: Is this function still classified as a &quot;fold&quot;, or is it something else? (And if so, what is it?)

Basically whenever anybody talks about folding, they always talk about folding _lists_, which is inherently sequential. I&#39;m wondering whether &quot;sequential&quot; is part of the definition of what a fold is, or whether this is merely a coincidental property of the most commonly-used example of folding.


What constitutes a fold for types other than list?

There are two types of iterators in Java: fail-safe and fail-fast.

What does this mean, and is the difference between them?

What are fail-safe &amp; fail-fast Iterators in Java

Reading up on the Java-8 spec, I keep seeing references to &#39;SAM types&#39;. I haven&#39;t been able to find a clear explanation of what this is.

What is a SAM type and what is an example scenario of when one might be used?

What is a &#39;SAM type&#39; in Java?

Is there any difference between a **web API** and a **web service** ? Or are they one and the same ? 

Content Type	Original Author	Original Content on Stackoverflow
Question	Hard Rain	View Question on Stackoverflow
Solution 1 - Javascript	HowDoIDoComputer	View Answer on Stackoverflow

What does `precision mediump float` mean?

Javascript Problem Overview

Javascript Solutions

Solution 1 - Javascript

UICollectionView: Animate cell size change on selection

How to change filehandle with Python logging on the fly with different classes and imports

Attributions