Activate your free membership today | Log-in

Friday, December 19th, 2008

Browser version 10 the new Y2K

Category: Fun, Opera

Here is a fun one for Friday, Hallvord Steen discusses the error reports coming in for Opera 10 that are to do with the version number.

That’s right, it appears that a number of people use the first character as the version number, which means that Opera 10 is showing up as Opera 1:

So we’re busy preparing the major upgrade from 9.5x and 9.6x - and what’s more obvious than calling it Opera 10? What’s in a name, or a version number?

Apparently a lot of trouble.

As Andrew Gregory already noticed, we’re the first browser ever to release with a two-digit version number. If websites assume that version numbers always have a one-letter “major” part and look for a single digit, they are going to “detect” Opera 1!

Since we released the first preview of Opera 10, we’re seeing the bug reports come in. Web sites go belly up because of their bad sniffing.

Posted by Dion Almaer at 3:30 am
11 Comments

++++-
4.9 rating from 28 votes

Friday, October 17th, 2008

MAMA, who is using Web standards?

Category: Opera

Ars discussed the new Opera initiative MAMA, the study that only 4.13% of the web is standards-compliant whatever that means :)

It is cool to see Opera doing this kind of work, with “Metadata Analysis and Mining Application (MAMA), a tool that crawls the web and indexes the markup and scripting data from approximately 3.5 million pages.”

Ian Hickson did some great work using the Google index to look at how developers use HTML, which lead to a lot of the HTML 5 features.

There were a couple of reports:

The URL set

MAMA’s analysis total is a mere fraction of even a single percent of such a daunting total. It seems odd to say that 3.5 million of anything is insignificant. So let us assume for a moment that it is not. We are just not able to look at every Web page, so we must choose a smaller group of URLs to look at and justify that this is representative of the whole Web. One option is to choose a set of URLs selected at random. I had some conversations with Rene Saarsoo (author of an excellent previous study on coding practices), and he brought up many excellent points about the structure of the Web and choices in URL sets—some of which I have tried to paraphrase here.

Markup Validation Report

Web standards are good for the Web! Most of the readers of this site will understand why this statement holds true—ease of maintenance, cross platform compatibility, access by people with disabilities, the list goes on!

But how does the reality of the Web hold up to these ideals? Surely with so many good reasons to code using open Web standards, the majority of sites should validate? Not so—Opera’s MAMA project has gathered a lot of quite shocking statistics showing that very few of the sites surveyed actually exhibit markup that validates.

Key Findings Report

Analysis showing:

  • Web servers used: Apache: 67.72%, IIS: 25.91%
  • Document structure and size
  • Flash detection
  • CSS styles used
  • Scripting
  • XMLHttpRequest object detection

Of course, it is easy to point to some potential flaws. Looking for “XMLHttpRequest” on a page doesn’t account for today’s reality on how XHR is used for example.

Doron Rosenberg pointed to some of these issues:

While it is no surprise that very few websites are completely standards compliant, their methodology seems flawed. Websites are doing more and more dynamic JavaScript stuff after page load which could affect such stats. Also, major JS libs are linked in via CDNs, so it is unclear how useful their XMLHttpRequest usage stat is.

But I can totally verify that chinese websites love flash. I still have nightmares from the AOL China gecko testing days. Flashing, scrolling, floating ads are scary.

That being said, it is great to see some data out there, and to give us a place to communicate. I would love to see more of this from Google, Microsoft, Yahoo!, and any provider that has a nice index of the Web.

Posted by Dion Almaer at 7:17 am
8 Comments

++++-
4.3 rating from 12 votes

Thursday, June 26th, 2008

Opera gets proactive and helps you fix your code

Category: Opera

Opera is being very pro-active and have been hiring folk to give compliance feedback for sites that aren't working well on Opera.

Nik Cubrilovic covered this on the new TechCrunch IT blog:

Opera Software is building a team of “web evangelists” whose job it is to find sites that do not display correctly in Opera and are not standards-compliant, and then email the site owners. They are sending emails with specific tips on how to fix HTML, CSS or other issues that don’t make sites compliant. Opera has always been a strong advocate for web standards, and this initiative is good for not only Opera but standards support on the web in general.

On the Opera jobs website, there are job listings for multiple web evangelist positions. They are hiring in Norway, China, South Korea, the Czech Republic and the USA - so it is a multi-lingual global effort.

How would you take the advice? An email like this:

Hello from Opera Software,

We have recently come to know that [retracted] is not displaying
properly in Opera. It stems from an Opera bug which we plan have resolved and should be out with the next release. However, till that time, it would be nice if you could tweak the site on your end to make it work with Opera.

Just add “overflow-y:visible;” to the “Body” of the web page in the CSS file. Or you can just put

CSS:
  1.  
  2. body {
  3.  overflow-y:visible;
  4. }
  5.  

In the <style> section of the pages, and it should make the pages display with Opera perfectly. If you have any more questions, please feel free to contact us.

If it was for general standards as well as Opera specific comments, then I would be quite happy :)

Posted by Dion Almaer at 7:34 am
14 Comments

++++-
4.5 rating from 11 votes

Thursday, June 5th, 2008

WiiExtJS: Building Ajax apps that run on the Wii Opera browser

Category: Ext, Opera

Shea Frederick has posted on building Wii-friendly web pages using the ExtJS library.

Shea focuses on the various issues that come up when building something for the Wii resolution, screen size, input types, and more.

For example, check out the layout:

JAVASCRIPT:
  1.  
  2. Ext.ns('Ext.ux.layout');
  3. Ext.ux.layout.wii = Ext.extend(Ext.layout.FitLayout, {
  4.     setItemSize : function(item, size){
  5.         var viewSize = Ext.getBody().getViewSize();
  6.         this.container.addClass('ux-layout-wii');
  7.         item.addClass('ux-layout-wii-item');
  8.         size.height = (viewSize.height-60);
  9.         size.width = (viewSize.width-60);
  10.         item.setSize(size);
  11.     }
  12. });
  13. Ext.Container.LAYOUTS['wii'] = Ext.ux.layout.wii;
  14.  

And then you can detect the Wii to set this layout:

JAVASCRIPT:
  1.  
  2.     Ext.isWii = navigator.userAgent.toLowerCase().indexOf("wii")> -1;
  3.     var layout = 'fit';
  4.     var title = 'Normal';
  5.     if (Ext.isWii) {
  6.         layout = 'wii';
  7.         title = 'Wii';
  8.     }
  9.  

Posted by Dion Almaer at 10:12 am
2 Comments

++++-
4.8 rating from 64 votes

Tuesday, May 6th, 2008

Opera Dragonfly: New Web Tooling

Category: Debugging, Opera, Utility

Opera Dragonfly

Opera has posted what looks like a great new Web debugging tool Opera Dragonfly which is released in alpha.

Debug JavaScript, inspect CSS and the DOM, and view any errors – Opera Dragonfly makes developing using Opera easier than ever, both on your computer and mobile phone.

Shawn Lauriat has a nice write-up that tells the story:

It offers most of the familiar tools for DOM inspection (along with a nice DOM editing capability), error logging (with the same granularity as before wrapped in a more polished UI), a JavaScript debugger that rivals WebKit's Drosera, a JavaScript thread logger, and a lot more that I haven't explored yet.

Time will tell whether Dragonfly can get enough developers to use Opera and keep them there, and how much the developers behind the new developer tools listen to the community in the coming iterations, but so far this looks extremely promising.

Features

  • Reach breaking point step by step: Opera Dragonfly's fully featured JavaScript debugger makes building sophisticated Ajax applications easier than ever. Step through your code line by line, setting break points along the way. This allows you to make sure your application and scripts are acting as you designed them.
  • Redefine your style: Its not just the DOM you can inspect. Check out what CSS rules apply to which element, and what rules are inherited or set by browser defaults. Overridden rules are highlighted so you can see what styles are or aren't applied. Support for editing CSS rules will be added in an upcoming version.
  • Spot your errors: An improved error console allows you to see, filter and log any errors in your scripts, pointing to the exact position the error occurred. Use this in combination with the other tools to hunt down and fix your site’s bugs.
  • Debug the DOM: View source isn’t much use if you use DOM Scripting to alter the DOM. Opera Dragonfly allows you to inspect the updated DOM and all it's properties. Support for editing the DOM will be added in an upcoming version.

The features that are not there yet, but are upcoming, include support for editing of CSS, JavaScript and the DOM, a single window mode, improved JavaScript thread handling, XHR and HTTP monitoring, improved keyboard navigation, and translation into a number of languages.

Have you checked it out? How do you like it?

Posted by Dion Almaer at 2:38 pm
10 Comments

+++++
5 rating from 31 votes

Thursday, April 3rd, 2008

Browser Update: Firefox 3b5 and Opera Mini 4.1 beta

Category: Firefox, Mobile, Opera

We have a couple of browser updates. First, we have Firefox 3 beta 5 which has improved integration with the host system, a better places organizer, and a bump:

Speed improvements to our JavaScript engine as well as profile guided optimizations have resulted in continued improvements in performance. Compared to Firefox 2, web applications like Google Mail and Zoho Office run twice as fast in Firefox 3 Beta 5, and the popular SunSpider test from Apple shows improvements over previous releases.

Opera also released a new browser with their Opera Mini 4.1 beta. The improvements talk about "faster" a lot: performance, finding things faster, and URL completion magic. This latest mobile browser also supports JSR-75:

JSR-75 is a specification for Java applications such as Opera Mini to access device internal storage and functionality within the phone. Some of Opera Mini features like "Save Pages" and "Download/Upload Files" vary on how much JSR-75 that is supported by the phone.

Posted by Dion Almaer at 1:57 am
5 Comments

+++--
3.9 rating from 17 votes

Wednesday, March 26th, 2008

Acid 3: Opera Passed?

Category: Browsers, Opera, Standards

It appears that Opera has passed Acid 3:

Since the test was officially announced recently, our Core developers have been hard at work fixing bugs and adding the missing standards support.

Today we reached a 100% pass rate for the first time! There are some remaining issues yet to be fixed, but we hope to have those sorted out shortly.

We will release a technical preview version on labs.opera.com within the next week or so. For now, the screenshot above shows the Acid3 test as rendered in our latest WinGogi Desktop build. WinGogi is the Windows version of our reference builds used for the internal testing of Opera's platform independent Core.

At the same time, Ian Hickson posted about changes to the test and Anne has commented that Opera is passing the latest and greatest:

"The updates from Ian have been done since the release of the test. Opera gets 100/100 on the latest version of the test."

  • Sub-pixel testing: It turns out that the original test accidentally required that browsers implement sub-pixel positioning and layout (and in fact the reference rendering got it wrong too, and relied on the same kind of rounding as Firefox does), which is somewhat dubious. I've changed the test to not rely on sub-pixel layout. However, it is very likely that this will be tested in Acid4, if we can get the specs to be clearer on this.
  • Surrogate pairs in SVG APIs: One of the submitted tests assumed that SVG APIs worked on Unicode codepoints, but the SVG spec changed to work on UTF-16 codepoints, like the rest of the DOM API, so the test was changed there. (The test changed a couple of times, because I originally got the fix wrong.)
  • The click() method: The test originally assumed that the click() method was reentrant, but the specs were vague on this and someone suggested making it fail if calls to it were nested, so I removed this part of the test (the spec hasn't been updated yet). I replaced it with an attribute test (the new second part of subtest 64).
  • The Performance Test: I made the loop counter in the performance test (a part of subtest 63) less complicated and shorter, to make it at least plausible that browsers could be fixed to pass that test quickly enough that it wouldn't always feel jerky. At the same time, I updated the test's infrastructure to report more details about pass and fail conditions and how long each subtest takes to run.
  • Namespace bug: Someone noticed that http://www.w3.org/1998/XML/namespace should have been http://www.w3.org/XML/1998/namespace in one of the subtests.
  • Linktest timeout
  • I made the linktest more resilient to slow network conditions. However, the test is still going to give you major issues if you are on a network with multi-second latency, or if the acidtests.org site is being slow.

Congrats to the Opera team!

Oh, and Safari is at 95/100 and will close in on 100 shortly.

UPDATE:

Hixie has another update:

Just as Reddit is celebrating Opera reaching 100/100, with the misleading headline Opera the first browser to pass the Acid3 test (hey, submitter: it wouldn't hurt to read the Opera blog post before submitting it to Reddit), the Apple guys track me down and point out that there's yet another bug in the test. With heycam's help, we have now fixed the test. Again. This presumably means Opera is now at 99/100... the race continues!

I have to say, by the way, that the relevant parts of the SVG spec are truly worthless. Where are the UA conformance criteria? You'd think a spec that was so verbose and detailed would actually tell you stuff, instead of just rambling on without actually saying what the requirements were...

Posted by Dion Almaer at 4:34 pm
17 Comments

++++-
4.5 rating from 18 votes

Friday, December 14th, 2007

Opera sues Microsoft of standards compliance

Category: Microsoft, Opera

Ah, the courts. The latest case aimed at Microsoft is from Opera, as they urge Microsoft to give consumers a genuine choice of standards—compliant Web browsers:

The complaint describes how Microsoft is abusing its dominant position by tying its browser, Internet Explorer, to the Windows operating system and by hindering interoperability by not following accepted Web standards. Opera has requested the Commission to take the necessary actions to compel Microsoft to give consumers a real choice and to support open Web standards in Internet Explorer.

"We are filing this complaint on behalf of all consumers who are tired of having a monopolist make choices for them," said Jon von Tetzchner, CEO of Opera. "In addition to promoting the free choice of individual consumers, we are a champion of open Web standards and cross-platform innovation. We cannot rest until we've brought fair and equitable options to consumers worldwide."

Opera requests the Commission to implement two remedies to Microsoft’s abusive actions. First, it requests the Commission to obligate Microsoft to unbundle Internet Explorer from Windows and/or carry alternative browsers pre-installed on the desktop. Second, it asks the European Commission to require Microsoft to follow fundamental and open Web standards accepted by the Web-authoring communities. The complaint calls on Microsoft to adhere to its own public pronouncements to support these standards, instead of stifling them with its notorious "Embrace, Extend and Extinguish" strategy. Microsoft's unilateral control over standards in some markets creates a de facto standard that is more costly to support, harder to maintain, and technologically inferior and that can even expose users to security risks.

Mary Jo Foley quickly chimed in on why it is a bad idea:

  1. Should antitrust courts be the ones in charge of determining which versions of Cascading Style Sheets (CSS), XHTML, Document Object Model (DOM) and other Web standards are the ones to which all browser/Web developers should be writing? Participants in various standards bodies can’t even agree among themselves which version of these standards is the best. How are judges supposed to wade through the browser-standards confusion in a good/fair way?
  2. Would it be positive for customers if Microsoft were suddenly forced to create a version of IE that looked good on paper, in terms of more complete standards compliance, but which broke third-party and custom Web applications? Microsoft has argued that it is trying to avoid this situation with IE and is working on various ways it can make IE more standards-complaint without breaking existing apps, completely upsetting the partner/customer universe.
  3. With Mozilla, Firefox has proved you don’t need government intervention to wrest a substantial percentage of the browser market from Microsoft. You just friends with deep pockets (like Google) and a community of dedicated developers — plus a guaranteed customer base who prefer anything other than Microsoft technologies.

    In the end, Microsoft’s own inertia, browser-security problems and inability to react quickly to market changes (where, oh where, is IE 8?) will continue to help its browser competitors more than a ruling by the EU or other antitrust body would.

    What do you think? Is Opera’s attempt to get the European Commission to force the unbundling of IE from Windows too late? And what’s your take on Opera’s attempt to get the courts involved in enforcing Web-standards compliance?

Posted by Dion Almaer at 12:01 am
37 Comments

++++-
4.4 rating from 44 votes

Saturday, November 17th, 2007

3D Canvas in Opera

Category: Canvas, Opera

Tim Johansson is talking about Opera's support for a 3d Canvas which differs from Mozilla's in that it doesn't map directly to OpenGL, which they did because:

  • It makes it easier to implement on non-OpenGL platforms (such as D3D)
  • We wanted to have some form of collision detection available

What can you do? Here is the interface that you get to work with:

JAVASCRIPT:
  1.  
  2. interface CanvasRenderingContextOpera3D {
  3.  
  4.   // state
  5.   void save(); // push state on state stack
  6.   void restore(); // pop state stack and restore state
  7.  
  8.   // scene/frame
  9.   void beginScene(); // start rendering a new frame
  10.   void endScene(); // finish rendering of the scene and present the result
  11.  
  12.   // transformations
  13.   void translate(in float x, in float y, in float z);
  14.   void scale(in float x, in float y, in float z);
  15.   void rotateX(in float rotation);
  16.   void rotateY(in float rotation);
  17.   void rotateZ(in float rotation);
  18.  
  19.   // rendering operation
  20.   void drawTriangle(in float x1, in float y1, in float z1, in float tex_s1, in float tex_t1,
  21.       in float x2, in float y2, in float z2, in float tex_s2, in float tex_t2,
  22.       in float x3, in float y3, in float z3, in float tex_s3, in float tex_t3);
  23.   void draw3DModel(in Canvas3DModel model);
  24.  
  25.   // create objects
  26.   CanvasTexture createTexture(in Image img);
  27.   Canvas3DModel create3DModel();
  28.  
  29.   // collision detection
  30.   string checkIntersection(in float x, in float y, in float z, in float radius, in Canvas3DModel model);
  31.  
  32.   // rendering state
  33.   attribute CanvasTexture texture; // current texture or null for no texture, default is null
  34.   attribute string color; // current color, default is transparent black
  35.   attribute float fov; // field of view of the scene in degrees, default is 45
  36.   attribute float nearPlane; // distance to the near clipping plane, default is 0.1
  37.   attribute float farPlane; // distance to the far clipping plane, default is 100
  38.   attribute string ztest; // "none", "less", "lessequal", "greater", "greaterequal", "equal", "notequal". Default is "lessequal"
  39.   attribute string blend; // "replace", "add", "srcalpha", "multiply". Default is "replace"
  40. };
  41.  
  42. interface Canvas3DModel {
  43.   void addVertex(in float x, in float y, in float z, in float s, in float t);
  44.   void addTriangle(in integer vertex1, in integer vertex2, in integer vertex3);
  45. };
  46.  
  47. interface CanvasTexture{
  48. };
  49.  

And, here is an example of a rotating cube (which you can see if you are using a new Opera build).

HTML:
  1.  
  2. <canvas id="canvas" width="200" height="200">
  3.   Canvas not supported!
  4. </canvas>
  5.  
  6.   var canvas;
  7.   var context3d;
  8.   var rotation;
  9.   var texture;
  10.   var cube;
  11.   function render(){
  12.     context3d.beginScene();
  13.     context3d.translate(0,0,-5);
  14.     context3d.rotateY(rotation);
  15.     context3d.rotateX(rotation);
  16.     rotation += 2;
  17.     context3d.color = "white";
  18.     context3d.draw3DModel(cube);
  19.     context3d.endScene();
  20.   }
  21.   function onTick(){
  22.     render();
  23.   }
  24.   function onload(){
  25.     canvas = document.getElementById("canvas");
  26.     context3d = canvas.getContext("opera-3d");
  27.     if (!context3d)
  28.     {
  29.       alert("3d canvas not supported");
  30.       return;
  31.     }
  32.     logo = new Image();
  33.     logo.src = "operalogo.png";
  34.     texture = context3d.createTexture(logo);
  35.     context3d.texture = texture;
  36.  
  37.     cube = context3d.create3DModel();
  38.     cube.addVertex(-1, 1, 1, 0, 0);
  39.     cube.addVertex(1, 1, 1, 1, 0);
  40.     cube.addVertex(-1, -1, 1, 0, 1);
  41.     cube.addVertex(1, -1, 1, 1, 1);
  42.     cube.addVertex(-1, 1, -1, 1, 1);
  43.     cube.addVertex(1, 1, -1, 0, 1);
  44.     cube.addVertex(-1, -1, -1, 1, 0);
  45.     cube.addVertex(1, -1, -1, 0, 0);
  46.  
  47.     cube.addTriangle(0,1,2);
  48.     cube.addTriangle(2,1,3);
  49.     cube.addTriangle(4,5,6);
  50.     cube.addTriangle(6,5,7);
  51.     cube.addTriangle(0,4,2);
  52.     cube.addTriangle(2,4,6);
  53.     cube.addTriangle(1,5,3);
  54.     cube.addTriangle(3,5,7);
  55.     cube.addTriangle(0,4,1);
  56.     cube.addTriangle(1,4,5);
  57.     cube.addTriangle(2,6,3);
  58.     cube.addTriangle(3,6,7);
  59.  
  60.     setInterval(onTick, 10);
  61.   }
  62.   document.onload = onload();
  63. </script>
  64.  

Posted by Dion Almaer at 5:51 am
14 Comments

++++-
4.7 rating from 20 votes

Wednesday, November 7th, 2007

Opera Mini 4 Released

Category: Opera

We just talked about how JavaScript and Ajax works in Opera Mini and today Opera released the full version.

Features

Opera Link

We've added support for Opera Link in Opera Mini 4. With Opera Link, you're able to instantly synchronize and share your bookmarks and Speed Dial with the Opera browser for your computer.

Overview mode

Opera Mini 4 includes a new rendering architecture that allows you to view webpages just like you would on your computer. When you first load a webpage, Opera Mini will show you an overview snapshot of the page; using the new mouse cursor you can instantly zoom in to the selected region of the page.

Size of text fits width of screen

Opera Mini 4 dynamically changes the size of the text on webpages to fit the width of your phone's screen, meaning you won't have to scroll horizontally.

Context menu

A context menu is displayed when pressing the number 1 key. From the context menu