Back to Droid

March 17, 2013 2 comments

2 years ago, on a whim, I decided to go Windows 7 Phone – for the 14 days until the droid I actually wanted became available. But I was impressed with the slickness of the device; that Windows 7 Phone UI – the UI where they got rid of all the reasons to need UI chrome – is really slick and elegant. Unlike the Windows 8 UI, which is a PC UI hacked to look like Metro and coerced into removing necessary UI chrome (but still needing it).

Ultimately, the lack of apps and an assortment of stupid feature changes are what sluiced me out of staying with Windows phone.

Windows Phone 7 Summary:

  • + Ultra-streamlined UI makes sense down to your bones after a few days adjustment,
  • + Great text-to-speech for reading text messages and giving alerts,
  • + Great speech-to-text – best I’ve seen so far for dictating texts etc,
  • + Fast little device
  • - One Volume Setting to Rule them All,
  • - Tendency to reset the volume to full on incoming calls, texts, or pretty much any sound,
  • - Speech functionality only available when you’ve have or have just had a bluetooth headset connected,
  • - No significant app support

Plus I had a grand-fathered unlimited data plan.

So today, I used my end of contract upgrade to switch to the Samsung Galaxy Note II.

It’s huge.

This may be a problem, because I’m a phone-in-pocket type of guy. The Note is HUGE. Half-way between my old phone and the size of my first-gen Kindle Fire.

In terms of the device in-hand, I like the size. In terms of portability – it’s bigger than my pockets. I bought an “Otter” belt-case for it. Yeah, that’s … just gonna take a normal guy’s pants down. The thing is huge.

Off the bat I had problems with the home screen customization. I want the time, date and temp displayed, sure. Do I want it so large I can only choose four other short cuts on that screen? Erh. No?

First App: HD Widgets.

Gives me a 2×1 clock + cal + weather widget. Replace the google search bar with a button and now I have a good 12 extra shortcuts on that page.

My contacts were mostly stored in Google and Windows Live so I got those imported nice and easily.

Getting Amazon Kindle running was a little bit of a pain.

And finally: There was selecting ring tones, alarm tones, notification tones and etc.

It didn’t come with a ringing phone tone. WTF.

And I’ll miss the alarm tones from the Trophy. I supposed I can always record them and make my own ring tones :)

 

Elite: Dangerous (at last!)

December 30, 2012 2 comments

It’s on, finally! The fourth chapter in the Elite franchise!

If you never played “Elite“, “Frontier” or “First Encounters“, I imagine you would be highly skeptical about the claims of “Elite: Dangerous“.

In 1984, Elite provided gamers with 256 galaxies of 256 stars, each of which had assorted planets and space stations. You loaded up with trading goods, bought fuel and launched out of Llave station to begin the process of trading, pirating and what not your way to the rank of “Elite”.

Those computers had 16Kb of memory. You are probably using a computer with 4-8Gb of RAM. That’s 260,000 times more memory than the computers of 1984. 1Gb is roughly 1 million Kb.

Then, 19 years ago, Dave Braben followed up with “Frontier: Elite II” and bent our minds: the game featured hundreds of thousands of stars, the entire of our galaxy, while at the same time allowing you to also go into the atmospheres and even land on the many planets and moons with cities and spaceports decorating many of the planets. All this is probably only 32x more memory than the previous version.

Today’s PC has 32,000x more memory than the computers “Frontier” was designed for.

Elite: Dangerous will be introducing multi-player to the Elite franchise, as well as bringing new depth and immersiveness to the game. Given how much Mr Braben has done with so little in the past, I’m really looking forward to seeing this chapter.

Right now they are pitching for funding on KickStarter – as of writing they’re at 1.1 million pounds of 1.25, 5 days to go!

Categories: Gaming, General Tags: ,

Assassin’s Creed III

December 27, 2012 Leave a comment

As much as I’m enjoying playing this game, the irks are … very, very irksome.

This is not a review of ACIII, it’s a rant. I am actually enjoying the game, just not nearly as much as I could be with small amounts of simple polish.

It also suffers from several cases of over-solving of problems where the combination of fixes actually create a new and – in a couple of cases – worse problems.

Like it’s predecessors and other PoP-ilk games, ACIII controls appear to be based on camera context rather than what you’d expect. On an HDTV this makes the games wickedly sensitive to display lag. When I tune RockBand/GuitarHero, my TV gets an unfortunate 75-100ms.

There’s something more than that going on: When I get into open combat, my character drops into an extreme pedestrian mode. He won’t jump over stuff, he won’t duck under things, he can barely climb the most basic climbing faces (and when he can, he’s usually so slow about it that he gets shot down again).

They also tried to simplify the controls down and so there’s a lot more “auto” stuff going on. They’ve added a GoW style “press to wall” behavior. It’s automatic. And it will do it against even half-height objects. Like tables, or rocks. Which is ok, if a little goofy. Except when it turns out that almost everything you need to interact with, ever, is on just such an object. Sure; you just have to learn to approach things you want to interact with slowly so that you can find the miniscule corridor where the button “interacts” as oppose to doing nothing or something entirely different (such as “drop”, because that’s also what the button does).

I also don’t understand what is with the lighting on the 360… Every face is in shadow, making them look ghoulish, and the lighting frequently flickers like mad.

Other frequent nuisances:

  • The camera doesn’t automatically come out of the down-over-the-shoulder view it uses when placing a snare, you have to run around to clear it.
  • There’s no way to dismiss your horse so if you’re not paying enough attention, it tramples and breaks your snares when you don’t even realize it’s still following you.
  • The bizzare “strangle-hold” thing while climbing synchronization trees when you are climbing the close-together branches and the camera decides to rotate at just the right moment that your “forward” stick pressure becomes slightly sideways; the only escape is to drop and die.
  • Ridiculously hard to pick up weapons during combat.
  • You wanted to send 3 wolf pelts on a convoy? Have fun scrolling thru all the selections 3 times.
  • After zooming in to kill a target, the camera stays zoomed in instead of auto-releasing (should be an option).
  • Sometimes you *can’t* loot a caravan – this may be that you need to move the guards’ bodies a really long way away.
  • To use a rope-dart, you’re supposed to hold Y and press L. Pressing L turns on Eagle Vision. Uhm.

 

Categories: General, Rants & Opinions Tags:

Private private members

December 1, 2012 Leave a comment

Private private members

Visualization of the concept in “Breaking up is hard to do“.

Categories: Coding, General Tags:

GNU sizeof, how odd

November 30, 2012 Leave a comment

Apparently, GCC doesn’t like the following second version of this simple piece of code:

size_t sizeInt = sizeof(int);    // Compiles on GCC, ICC and VS.
size_t sizeInt = sizeof((int));  // Compiles on ICC and VS.

GCC complains:

expected primary-expression before ‘int’

Sigh.

Categories: Coding Tags:

Breaking up is hard to do (to member functions)

November 19, 2012 23 comments

Want to bounce this off some other coders before I make a language-change proposal of it:

C#’s “partial” class type lets you spread a class definition across multiple files. But mostly people use it as a way to make private code definitions private – split large functions up into little nuggets that don’t get exposed in the primary API while still having membership status to access member variables, etc.

The downside is: it actually lets you add crap to the class in your own definitions, forming part of the need for the “sealed” accessor type in C#.

In C++ your choice is (a) huge member functions, (b) Pimpls, (c) classes that list zillions of private members in their public API.

Seems to me, a simple combination of existing keywords would let you create non-public, compilation-unit scoped temporary member functions so you can break a large member function up without all the hassles that come from breaking a member function into private local non-member functions.

Specifically the term “private”.

By marking them this way, the following constraints/restrictions/behaviors would naturally fall out of the current language definition:

  • Cannot be virtual (if it goes in the vtable, it goes in the ‘class’ def,
  • Cannot be abstract (since you’d have to declare it in the class),
  • Cannot share a name with a well-defined member function or variable,
  • Not visible to derived classes even if they are in the same compilation unit, (as applies to any ‘private’ member)
  • Cannot be an operator, (that could lead to some nightmare situations)
  • Cannot be static (static members aren’t limited to ‘public’ access, so there are actually good use cases for ‘private static’)
/// Header file Foo.h
class Foo {
public:
  Foo() : m_bar(“”), m_i(0) {}
  void bigFunction();
  void otherFunction();
private:
  void privateFunction();
};

 

/// Foo1.cpp
#include “Foo.h”

private void Foo::helper1() {
  m_bar = “hello”;
  m_i = 1;
}

private inline void Foo::helper42() const; // prototype variant.

void Foo::bigFunction() {
  helper1();      // member call
  …
  helper42();	// member call
}

void Foo::helper42() const {
  m_bar = “world”;
  m_i = 42;
}

class Bar : public Foo {
  …
  void barMember() {
    helper42(); // Error: it was private to Foo.
  }
};

 

/// Foo2.cpp
#include “Foo.h”

private void Foo::helper1() {
  // Legal, because helper1() was private-unit-scoped in Foo1.cpp and is thus not visible here.
}

private void Foo::privateFunction(const char* const message) {
  // ERROR: The finger print is different but the name conflicts with an established
  // ERROR: member function name, so this isn't legal.
}

void Foo::otherFunction() {
  helper1();	// Invokes the helper1() declared in Foo2.cpp above.
  …
  helper42();	// Error: helper42 is only unit-visible in CPP file #1.
}
Categories: Coding Tags:

Have you ever EOLd an SSD?

October 16, 2012 11 comments

I’ve heard and read various things about how SSDs die. But how do they actually die? The failure process seems like it should be more methodical than spindle drives, given less factors, so if you have X many of the same SSD drive and none of them suffer manufacturing defects, if you repeat the same series of operations on them they should all die around the same time.

If that’s correct, then what happens to SSDs in RAID? A mirror configuration isn’t necessarily going to result in the exact same sequences of write operations – which means that, at some point, your drives might become out of sync in-terms of volume sizing. Stripe, at least, has some chance of distributing the wear.

But has anyone actually deliberately EOLd SSDs in various configurations to see whether they die with dignity (and manageable degradation rates) or are people in for a shock when one day they find their SSD raid array is down to 70% capacity and is going to be dead in the water before replacements can arrive?

 

Categories: General
Follow

Get every new post delivered to your Inbox.

Join 183 other followers