Read more of this story at Slashdot.
Read more of this story at Slashdot.
Read more of this story at Slashdot.
Canon EOS 40D, Canon 17-40mm ƒ4, tripod
I know it’s early, but sometimes you have to seize the day (carpe diem!)
On Flickr there’s also a partial desaturated version of the same photo.
Technorati Tags: fotografia, firefox, wallpaper
←
→
Read more of this story at Slashdot.
I put together a demo of incrementing numbers in URLs by scrolling.
Hopefully it's not considered a bug that I can use rangeOffset for a text node "inside" a textbox ;) Trying to access rangeParent throws a security exception.
This could be used by an extension like URL Flipper as a shortcut for changing specific numbers in URLs.
Read more of this story at Slashdot.
Bit of a weird week – very busy, but not a lot of coding.
Tab matches in Awesomebar StatusRelated posts:
Read more of this story at Slashdot.
This week brings a boost in visibility of results, not just for startup, but for all the performance testing we’re doing on all branches and platforms. As I mentioned last week, I was working on an automated method of generating the cross-branch startup results. Luckily Johnath and Chris Atlee had done the hard work when making the performance dashboard. It has a JSON file that contains a roll-up of the previous 7 days performance data, which is updated every 5 minutes with new Talos results. Using that as the datasource, I wrote a script summarizes the results for each test+branch+OS combination across all the boxes that returned results, as well as stable branch and previous week differences. The final product gives a snapshot view of how each branch compares to the stable branch.
This is useful for a few different reasons. First, we (and the press and our users and our managers and everyone really) are able to know at-a-glance how any branch compares to the stable release branch. An example of another use is that before the JS team does a Tracemonkey merge, they can quickly see if any major performance effects can be expected.
The table shows red or green for any differences that are outside of a 2% threshold, to take test noise into account. This is quite liberal, as I’ve already calculated the numbers to take into account whether the difference is within the standard deviation. Reducing the noise in the tests would be a big help – perhaps some researcher will take up Roc’s challenge. A second point of trust is my math I’m not a statistician, so please view source and let me know where I’ve miscalculated.
An example of the full report is here. I’m going to file a bug and work with release-engineering to get it pushed out to the graph server, where the dashboard lives. The data from this week’s startup table is copied below (though sans the color-coding of the real thing. Actually, now WordPress keeps stripping out my styles, so you get an ugly table this week).
Ts Firefox3.5 Firefox3.6 Firefox TraceMonkey Leopard median: 1469
deviation: 110
mean: 1481
from last week: 2%
median: 1115This week’s activity:
Projects in a holding pattern:
As usual, more details and links are available on the project wiki, and we’re available to answer questions in #startup on irc.mozilla.org.
Nearly 3 month after we have released Mozmill 1.2 we are close to our next release of Mozmill. Lots of bugs have been fixed and even a couple of new features were implemented. A nearly complete list you can find on Bugzilla.
Everyone who is using Mozmill regularly is welcome to help us in testing the beta version. As long as no big issues will come up the release of Mozmill 1.3 will happen next week.
If you want to test the extension please download it from Github.
Users of the pyPI packages only have to run “easy_install -U mozmill” to get the latest packages for Mozmill, JSBridge, and Mozrunner.
Thanks in advance.
gietfirebug.com has Firebug 1.5b3. This is 1.5b2 with a couple of fixes. It passes all tests on Firefox 3.6b2 and does not crash in Firefox 3.7 nightly. Two tests fail in Firefox 3.7. One is a change in an error message; the other is some mystery message we need to ask mozilla platform folks about.
jjb
Last week I was in Canada to present at FSOSS with David Humphrey on awesome Mozilla Tools: Dehydra, DXR, Pork, etc. I think we managed to convey the message regarding what a sad affair that current developer development tools are.
General-Purpose Dehydra Scripts
Dehydra grew out of Mozilla’s constant need to figure out what is going on in the source code. As a result most of our scripts are very Mozilla API-specific. This makes harder for people outside of Mozilla to learn Dehydra. There is no library of Dehydra code that one can just plugin to start analyzing their codebase. Instead one has to sit down, figure out what Dehydra is capable of and then see if any of the problems facing the developer can be solved this way. If anyone wants to contribute such a library, let me know.
In the meantime, more general-purpose analyses are surfacing.
Shadowed Members
My favourite script so far is the member-shadowing checker. I ran into a member-shadowing warning that is unique to Sun’s C++ compiler. It was triggered by some code that I just landed on the tree. I fixed the warning, but within a few days a coworker ran into a bug caused by that member shadowing(due to having an unlucky revision of the code). The following example shows how simple it was to implement the warning in GCC/Dehydra.
<iframe height="300" src="http://people.mozilla.com/~tglek/shadow.html" width="95%"></iframe>
See bug 522776 for the complete story on adding the member shadowing check to Mozilla.
Printf
Another general purpose analysis was done outside of Mozilla by Philip Taylor for his game. His script checks wide printf format strings (which are overlooked by gcc).
Independently, Benjamin wrote a printf checker for Mozilla printf-like code, see bug 493996.
Custom Sections in Object Files
We have long speculated about how nice it would be if Dehydra could emit info into object files that could then be yanked out of the resulting binary (by say, valgrind). bug 523435 will soon make that a reality.
Read more of this story at Slashdot.
Gracias a los patrocinadores de esta semana en Tecnoculto, por ayudar a que este blog siga adelante: Oidococina! Internet deconstruida, Videos chistosos (Kiubbo.com), e-Viral y, por supuesto, a Google Adsense.
Nota: Hoy se terminan mis vacaciones… ¡Cuantas sorpresas me tenían preparadas los patrocinadores! ¡Wow! Todavía no puedo creer que rentaran esta paradisiaca villa a la orilla del Caribe, con playa privada. ¡Gracias!
Copyright 2007-2009 Tecnoculto, Blog de Tecnologia, Cultura y Puntos Intermedios.
Si ves este articulo en algun otro sitio que no sea tu lector de feeds, es de forma ilegal
Link al Articulo Original:
Gracias a los Patrocinadores de Tecnoculto…
WebGL introduces two interesting concepts that I think have application outside of WebGL, the CanvasArrayBuffer and CanvasArray. This is all subject to change, of course, though this is what the current Gecko (and others') implementation looks like. In particular, the Canvas prefix in the names might change soon.
It became clear that pure JS arrays are not a useful way of shoveling around lots of 3D data; their very flexibility makes them impractical for performance-critical uses. In particular, WebGL often wants to deal with arrays of a specific type -- an array of integers, an array of floats, etc. Even more complicated is the need to manage multiple types within a single memory region; for performance, it's often preferable to allocate one chunk of video memory, and place coordinates, colors, and other types in there, replacing them as necessary.
There are two portions to the solution: the CanvasArrayBuffer and a set of typed CanvasArray views. A CanvasArrayBuffer represents chunk of data. It can be allocated with a size in bytes, but it can't be accessed in any way. To actually manipulate the data inside a CanvasArrayBuffer, a CanvasArray has to be created that references it. An example:
var buf = new CanvasArrayBuffer(3*4); var floats = new CanvasFloatArray(buf); floats[0] = 12.3; floats[1] = 23.4; floats[2] = 34.5;The above chunk of code allocates a 12-byte CanvasArrayBuffer, and then creates a float-typed view onto the buffer which can then be manipulated (almost) like a normal array. Of course, the above is cumbersome to write, so there are shorthands that will allocate a CanvasArrayBuffer, and optionally fill it with data from a JS array:
var f1 = new CanvasFloatArray(3); var f2 = new CanvasFloatArray([12.3, 23.4, 34.5]);The size of each CanvasArrayBuffer is fixed; there is currently no way to change its size once allocated.
Multiple CanvasArrays can reference the same CanvasArrayBuffer. For example:
var buf = new CanvasArrayBuffer(12*3*4+12*4); var points = new CanvasFloatArray(buf, 0, 12*3); var colors = new CanvasUnsignedByteArray(buf, 12*3*4, 12*4);This creates a buffer of 192 bytes, which is enough room for 12 3-coordinate float points followed by 12 RGBA colors, with each component represented as an unsigned byte. The arguments to the CanvasArray constructors are the offset from the start of the buffer (in bytes), and the length (in elements). The offset must always be a multiple of the element size (to preserve alignment), and the buffer must obviously be large enough for the given offset and length. If length is not given, the length is assumed to be "from offset until the end of the array buffer"; that value must be a multiple of the element size. If offset is not given, it's assumed to be zero.
For extra complex use cases, CanvasArrays can reference overlapping regions of a CanvasArrayBuffer:
var buf = new CanvasArrayBuffer(192); // same value from above var points = new CanvasFloatArray(buf); var colors = new CanvasUnsignedByteArray(buf); points[0] = 12.3; points[1] = 23.4; points[2] = 34.5; colors[12] = 0xff; colors[13] = 0xaa; colors[14] = 0x00; colors[15] = 0x00;In the buffer, this writes 3 float values followed by 4 byte values. You'll note that this use is significantly more complex, and requires the user to keep track of the current position in terms of whatever element they're modifying (thus setting array elements 12, 13, 14, and 15 for the color).
If an attempt is made to store data in a CanvasArray that doesn't fit within the right type, a C-style cast is performed. If the data is an entirely wrong type (e.g. trying to store a string or an object), Gecko currently throws an exception, but this might become a silent 0 or similar in the future.
Where does this fit in WebGL? Any API function that needs an array of data takes a CanvasArrayBuffer. This avoids placing costly JS array type conversion in a potential critical performance path, and simplifies a number of aspects of the API. So, VBOs, texture data (if not loaded from a DOM image element or from a CanvasImageData object), index array, etc. all use CanvasArrayBuffers/CanvasArrays for pulling data in and out. CanvasArrays also help manage memory usage -- an array of byte color data now takes up exactly as much memory as needed, instead of getting expanded out to 4 bytes. Also, critically, floating point data can be stored as 32-bit single-precision floats instead of 64-bit doubles, taking up half as much space when the underlying graphics system can't support 64-bit values.
This API is overall lacking in developer niceties, since the focus was on providing the necessary functionality. Higher level wrappers can be written in JS to simplify usage. In addition, by keeping it as bare-bones as it is, it allows for fast implementation on native hardware via the JITs in all the current-generation JS engines. The web currently fudges around the problem of binary data by passing it around either in strings (because JS strings are UCS2, therefore all 8-bit elements are valid, but with a performance and memeory cost), or often encoding as base64 (again going back to strings). I can see this type of dense/native type access being useful for both the File and WebSockets APIs as a way to exchange and deal with binary data.
Read more of this story at Slashdot.
El hosting de este sitio es proveído por: