I'm posting from a ChromeBook pixel running at 2560 x 1700, and the UI looks great. The taskbar, UI, fonts, etc. are all scaled perfectly.
Have you tried running at 2560 x 1700 on the most up-to-date version of ChromeOS? Some of the issues you had may have been fixed in more recent Chrome releases.
The author of this article quotes two bits from the speech:
>We have made no mistakes about your admission.
and
>You all deserve to be here!
The first statement is the more important part. Incoming freshmen meet an extremely talented group of people when they arrive on campus. It's easy to be intimidated by what others have accomplished before even getting to college. The point of this speech isn't to comment on the service undertaken by students, but rather to reassure them that they are capable of performing at the level of the peers they're so impressed by.
I continue to be impressed by the uses Google has found for Chrome. Building new features into Chrome gives Google the capabilities of a full desktop application without the need to convince users to install new software. Google can just issue an update to Chrome to instantly ship new projects to ~20% of web users.
I'm one of the TAs (section leaders) for 106X this quarter. We get a pretty wide diversity of skill levels in the class, so it's tough to ensure that we challenge the experienced students while not scaring off everyone else.
However, the goal of 106X isn't to teach all of the complexities and nuances of algorithms (take CS161), fundamental principles of computing (take 103), or OS/low level understanding (take 107/140/143). Sure, we'd like students to think about these things, but we really want to make sure that students know how to program with
* Proper decomposition
* Sensible commenting/documentation
* Use of appropriate data structures/knowing when to employ recursion
If you want to get more "huh, that's cool", try taking 107 in the winter (Jerry is teaching that course as well).
Clang, GCC, and Intel are all described as "mostly" supporting C99. This is unfortunate, and it would be nice to see them fully supported, but developer time is limited, and not all of C99's features are in high demand.
Unlike MSVC though, these compilers have included the extremely visible features -- things like inline variable declarations, designated initializers, and variable length arrays. I don't think Microsoft should implement C99 in full, but partial support would help students trying to learn C on Windows.
For students, they could use Pelles C (http://www.smorgasbordet.com/pellesc/) which has support for C99 and C11 and is free as well. There are well established alternatives to C99. At this point, Microsoft would be trying to play catch up which would take away from other areas of focus.
I guess the difference between mostly for Clang and GCC and full for Sun Studio and IBM is the difference between having a PR department and being an open source project.
I think the author could have chosen better data for this calculation. There are a few unusual factors:
* Why use average income? Why not median family income?
* Why use median $/square foot, and then assume a 2000 square foot house? Why not just rely on median sale price?
I looked up the data for San Francisco, where median family income is $81,136 and median home sale price is $705,000.
Using the same methodology but with these income/price numbers, saving up for the down payment on a home in San Francisco takes ~14.5 years instead of 20.6. I'm not sure how this compares to other cities, but I think it's a bit more reasonable of an estimate of how long it takes to "save up for a house" in San Francisco.
Haskell uses type inference, but that's not the same as implicit coercion, which Haskell explicitly avoids. That is: if you type
4 + 4.2
Then the compiler will infer that you mean
(4::Fractional a=>a) + (4.2::Fractional a => a)
However, you cannot add an integer and a float:
(4::Int) + (4.2::Float)
Couldn't match expected type `Int' with actual type `Float'
In the second argument of `(+)', namely `(4.2 :: Float)'
In the expression: (4 :: Int) + (4.2 :: Float)
In an equation for `it': it = (4 :: Int) + (4.2 :: Float)
This follows from the type of (+) :: Num a => a -> a -> a
Haskell uses type classes to support ad hoc polymorphism, or overloading. Consider the statement:
(4.2::Fractional a=> a) + (4::Float)
Float is an instance of the type class Fractional. That is: methods which are defined for all fractional types must be defined for floats.
The compiler infers that (4.2::Fractional a=>a) must have type float, as it is being added to a float.
This is compatible with the original type of the expression, as Float is an instance of fractional, so it is valid to read 4.2 as a Float.
I always thought x.y.z version strings (like Firefox 3.6.3, or similar) contained a bit of extra information about how development occurs which is often ignored.
When z is increased, that is the developers way of saying that "this is the least dramatic update we will make available to end users". Alternatively, an increment of a is a sign that "this is the most dramatic alteration in functionality we will make".
I think that part of the trend toward higher version numbers isn't just about having nice big numbers, but rather a reflection of changes in development methodology. Whether you attribute it to DVCSs or simple changes in developer culture, it seems clear that the "biggest possible" update has significantly shrunk in size lately.
Have you tried running at 2560 x 1700 on the most up-to-date version of ChromeOS? Some of the issues you had may have been fixed in more recent Chrome releases.