I think that's a perfect tl;dr. :)

The 'Relativity' one is also quite nice: http://www.andrewlipson.com/escher/relativity.html

Click on the zip icon to download it: https://img.skitch.com/20120726-nd9jxi6gwa32tnkjxwrehewpcn.p...

You can also download it directly from the website if you don't want the source code bundled along with it: http://sicpebook.wordpress.com/ebook/

I would also add that the study of art and design history was the key thing that liberated me from the fear of copying. Extremely valuable.

I think this highlights something that is missing from the article. That is, the importance of hierarchy. Colour, contrast, position and weight (ie. 'boldness') are all highly important in communicating the order of importance. One should be able to squint a distance away from the page and know instantly where the most important elements are.

For technical skills, I would recommend using Photoshop for web/ui design. Unfortunately at the moment it's the best out there. Some good things to seek out are adjustment layers and layer effects. Bjango has some great tutorials, although they are focused on UI design: http://bjango.com/articles/

In terms aesthetics, the most import thing is to develop your 'design palate'. Seek out excellent craftsmanship and learn to distinguish it from the mediocre. An excellent place to start is SiteInspire: http://siteinspire.com/

I would also recommend learning the fundamentals of design. Typography and grid systems are very important study areas. A great place to start is this forum thread: http://www.designerstalk.com/forums/graphic-design/42390-des...

For empirical testing of designs, I would highly recommend Lukas Mathis' Designed for Use: http://pragprog.com/book/lmuse/designed-for-use Be warned however that the print version is horridly designed, just get the .epub to bypass the ugly formatting.

And always have in the back of your mind: 'less is more'. Just because you've learned how to do fancy gradients, reflections and rounded corners, doesn't mean you should.

Thankyou for such an informative post, I have ordered the book. The forum posting on designerstalk is pretty awesome.

No worries! Designerstalk is also an excellent place to get harsh, truthful feedback on your work as opposed to the unhelpful 'that's great' replies. That said, I haven't been on there in a while so things might have changed.

The important thing is to seek out folks who give honest, constructive critiques and aren't afraid of 'offending' you in the process. The most annoying thing when seeking out design critiques is to be told over and over, 'that's really good'.

How did you solve the problem in your matrix libraries of overloading a single operator multiple times? I was trying to make rudimentary, game-oriented linear algebra library in rust along the lines of glm. I immediately ran into the problem of not being able to implement "mat4 * float->mat4", "mat4 * vec4->vec4" and "mat4 * mat4->mat4" overloads at once. The alternative was only to go with "mult_float", "mult_vec4" and "mult_mat4", but as you say this leads to "nigh-unreadable" code.

It might seem petty, but whilst I understand rust avoiding overloading functions entirely (due to type problems and code obfuscation), it was enough to turn me off entirely, in this case sending back to D.

Bear in mind this is not to say Rust is a bad language - there's plenty to like about it. ;)

I was about to say "you can't do it", but I think you can -- the trick is to use a bounded generic implementation. Once "Mul" becomes a trait, you'll be able to say this:

    trait MatrixMultiplyRHS<Result> {
        fn mul(matrix: Matrix) -> Result;
    }

    impl<RHS:MatrixMultiplyRHS<Result>,Result> Matrix : Mul<RHS, Result> {
        fn mul(rhs: RHS) -> Result {
            rhs.mul(self)
        }
    }

    impl float : MatrixMultiplyRHS<Matrix> {
        fn mul(matrix: Matrix) -> Matrix {
            // ...implementation of matrix scalar multiply...
        }
    }

    impl Vector : MatrixMultiplyRHS<Vector> {
        fn mul(matrix: Matrix) -> Vector {
            // ... implementation of matrix multiply for vectors ...
        }
    }

    impl Matrix : MatrixMultiplyRHS<Matrix> {
        fn mul(matrix: Matrix) -> Matrix {
            // ... implementation of matrix multiply for matrices ...
        }
    }

It's admittedly a bit awkward, but maybe that's OK to discourage overloading unless you actually need it. Still, your point was very interesting -- I didn't realize this was possible! -- and I'll spread it around the team.

Ahh neat.

Just as a warning, I've already aired this topic on github, so maybe that might be a good place to discuss it: https://github.com/mozilla/rust/issues/2961

I don't want to cause a fuss. While Rust might not work for my needs/wants/desires, that's ok. I highly respect those who don't attempt to please everyone. :)

I don't know rust but rust seems very much like C++.

Did you have a look at the Eigen library (C++)?

http://eigen.tuxfamily.org/dox/TutorialMatrixClass.html

I have never worked with this library but it seems to me that they have not the problems you described. Maybe having a look at it brings up some new ideas...

Although on superficial level it shares the AGOL/C-style syntax, Rust is a very different language from C++. Some things are possible or easier in Rust as opposed to C++ and vice-versa. Copying directly from a C++ library would be difficult, and wouldn't take advantage of Rust's unique strengths.

Okay. Thanks for the info. I just had a quick look at Rusts wikipedia entry and saw that it has been influenced by C++. But as you pointed out, this might not mean much...