Dev.SN

Mozilla Creating a Language for Building Browsers

posted by janrinok on Saturday March 15 2014, @06:07PM   
from the we-always-need-new-languages dept.

An anonymous coward writes:

"Mozilla is using work on it's next generation layout engine, Servo, to fine tune a new language used for writing that layout engine. The new language, called Rust, started as a personal project of Greydon Hoare and has since grown to be sponsored by Mozilla and Samsung. From the article:

The Rust language will power Mozilla's new browser, Servo, and its big selling point is efficiency. Because C++ crashes when it runs into memory allocation issues, it weakens any browser that uses the language. Mozilla designed Rust to be superior to C++ this way, more easily isolating tasks and promote a process known as "work stealing," which is when tasks from an overloaded processor are shifted over to another one.

Rust is a general purpose, multi-paradigm, compiled programming language developed by Mozilla Research. It is designed to be a "safe, concurrent, practical language", supporting pure-functional, concurrent-actor, imperative-procedural, and object-oriented styles."

• Re:New language (Score: 1) by No.Limit on Sunday March 16 2014, @12:24PM

  by No.Limit (1965) on Sunday March 16 2014, @12:24PM (#17200)

  A programming language is the most fundamental tool of a coder. Every advancement in programming languages is a blessing to all of us coders!
  
  Of course we already have languages with really great features (C, C++, Java, C#, Python, Haskell, Ruby etc). But while they're good, there is always room for improvement as can be seen by language updates.
  
  The _recent_ C++11 standard introduced many awesome features to C++. Simple and easy ones like inferred types or syntax for iterations (for (auto myIterator: myContainer) { /*...*/ }).
  Highly flexible ones like lambda expressions (also new in Java 8). Important concepts such as move semantics and more.
  
  But there are limits to how much we can improve existing languages. These languages always have to try to keep as much backwards compatibility as possible and that severely limits how much they can really change and improve.
  
  A good example is the null reference or also the 'Billion Dollar Mistake' (that actually comes from the inventor). At this point we know we can guarantee null-pointer safety by for example extending the type system to distinguish between references that could be possibly null and references that are guaranteed not to be null.
  
  Here an example:
  
  reference? couldBeNull = null; // denoted by a question mark after the type
  reference guaranteedNotToBeNull = new SomeClass(); // no question mark, so always non-null
  
  if (couldBeNull != null) {
    // here the type of couldBeNull changes, because here it's guaranteed not to be null
    // here we can dereference both couldBeNull and guaranteedNotToBeNull safely
  }
  // here we can only dereference guaranteedNotToBeNull safely.
  
  And this goes beyond forcing coders to do null pointer checking. With this we can also guarantee that functions get non-null references with the type system.
  In fact we can prove that there will never be a null pointer exception in the whole program!
  
  And there are so many more awesome features that languages could have and that guarantee safer programs. I for one embrace every exploration of language design hoping that in the future we'll have even better and safer languages!

  Parent