Author: midknight

Industry Trends and In-House Servers

Looking back over the last several years, several things have changed. One definite trend that has shown up over the last couple years has been that of smaller offices and businesses getting away from in-house servers.

I guess you can blame it on the “cloud.” Or at the very least, the fact that for many of the reasons people felt they needed a server, they are still better served by a “cloud” based service, or leasing one offsite.

What are the use cases? What are the pros and cons?

Most of my clients use servers for the following reasons:

  • Email (often exchange)
  • File sharing
  • Shared printers.
  • Custom, served applications (remote desktop or server-client programs like accounting or CRM applications)
  • User and security management

Now, to be utterly honest, when you look at the cost differential over the years, even factoring in typically higher oversight and support costs for in-house servers, you will probably spend more for hosted or cloud based services after three years than you will on an in-house box, but that doesn’t mean it’s a bad value. For one, many of the cloud-based services use standard formats that make it easy to get your data back out and migrate it elsewhere if needed, so lock-in is minimal. For two, though you may pay a few percent more, you usually have the option to quit at any time if flexibility is paramount. Last, unlike a typical small office somewhere relying on their DSL or cable provider, you can often get far more responsive and reliable connectivity to your services while out of the office than you do with an in-house server, without the added headaches of configuring firewalls or VPN’s.

Additionally, with in house servers, your data is absolutely yours, and always (unless stolen, you do keep a copy offsite somewhere, right?) available to you.

So let’s look at some substitutes for in-house servers.

Email:

If people are storing email in house, it’s almost certainly on an Exchange server. There’s a lot of good things I can say about the capabilities of Exchange, but given that 80% of what smaller companies use exchange for (email, shared calendars, delegation of email roles) can be handled by the free version of Google Apps, there’s not much reason to stick with Exchange just to have @whateveryourdomain.com in your email.

If you really, really need exchange, there are also hosted exchange providers like Intermedia who, among other things, provide full Blackberry integration and wireless sync.

All of these are free, or at a reasonable cost compared to licensing and maintaining an exchange store, and they’re accessible from anywhere, on any device.

File Sharing

If you don’t have absolutely huge amounts of data, It’s possible to lease some space online using shared Dropbox or Jungledisk “workgroup” accounts, and then share your files with your office no matter where you are. Both allow you to access your files from the web in an emergency, and Dropbox even has mobile apps for the Android and iPhone. 

When it comes to backing up your data, Dropbox stores the last 30 days of changes to your files, while Jungledisk allows you to not only back up your shared files, but as many computers as you’re willing to cover by simply setting aside the space needed to cover your backup needs.

Speaking of backups, you also have Mozy, which allows you to create both local and remote backups of any computer or even server in your office, thus reducing the need for a server just for backups.

Shared Printers

Networkable printers are relatively cheap, and most network capable printers can easily be detected and setup using some variant of zeroconfig (Bonjour for macs, and downloadable for Windows). Most smaller offices don’t change printer setups that often, don’t need to manage user access or permissions for said printers, and don’t change the network often enough to justify buying a server to set up printer sharing. They also don’t have enough of them to need a central directory to find them all.

Custom Applications

In a lot of cases, server-client configurations are so network intensive that putting them on their own server is often a necessity anyway, and with VPN performance being totally unworkable, the best solution is often to bite the bullet and just run the program under terminal services for everyone. Again, this almost always requires a separate machine. 

At that point, checking out a hosted application provider like Trapp Online for a small handful of users suddenly gets much more attractive. Where reliability and availability are absolutely paramount (accountants across a number of states, etc., and needing to maintain operations even with local disasters and hurricanes), the availability and high grade internet connections of the better hosted providers justifies the higher long-term price tag for even larger numbers of users.

User Management

This is where hosted service still fail. While most of them are very good about letting you control security and user access, spreading out your services across a number of providers complicates administration, application, and tracking of passwords.

But then, if you’ve got 50 or more users, you probably still have very good reasons to need your own in-house server, including the employee base to justify it and a better ability to handle the IT overhead. You also will likely need the fine-grained control that buying your own servers gives you – even if only making it far, far easier to maintain security and antivirus software.

 Summing it All Up

For many smaller businesses, the advances of modern internet-based services, and the need for mobility and access to information even when not at the office make hosted or cloud solutions a great value when you consider the lower startup costs, and the gains in flexibility and power. It’s far from a universal fit, but keep it in mind.

My Experiment with Chrome

Chrome, is the rather nifty browser from Google that is also being used as the foundation of the “ChromeOS” based netbooks that will be coming out. 

In the past, I had used Chrome as an alternative to Safari when I needed to cross-check web rendering for building web sites, and more frequently, when logging into google-based accounts other than my main one, since Chrome does a better job of handling multiple windows for multiple google-based accounts. Otherwise, it was all safari, all the time.

Because of this behavior, and it’s faster rendering, I decided to give Chrome a shot as my primary browser. A serious shot.

So I moved all of my bookmarks over, and had at it. At first, all was well. In addition to the above mentioned advantages, I really liked how Command-clicking on nested links in my toolbar didn’t replace my window instead of adding new tabs. I also really liked not having to tab over to a separate search bar. 

I was enjoying it so much that I even went to the trouble of rearranging and slimming down my bookmarks.

You can almost hear the “but” coming.

First of all, there’s no way I can find or figure out to manually add a link to the default new-page “tab” view. It’s clumsy enough in Safari, requiring two windows, but it’s doable.

Secondly, the bookmark manager, while nice enough, just isn’t up to par with that in Safari, especially when you keep a running folder of “to look at” links that you regularly flush out. This is a matter of personal taste.

Thirdly – using Logmein (for several clients) effectively requires me to open up Firefox or Safari anyway.

Fourth – some pages like the app store management pages simply didn’t load quite right in Chrome.

Fifth – printouts did not get the web address posted into the header or the footer of the page like they do with Safari.

Sixth, while the plugin for 1Password generally worked flawlessly in Chrome, there were several sites that worked without hiccups in Safari that required me to disable features like auto-logon.

I could live without these features, but it was already a near-run thing, as the downsides began really encroaching on the reasons I really, really wanted to switch over in the first place.

So of course, Google decides that in the near future, for reasons of “openness”, Chrome will no longer support the video codec named H.264. They’re keeping Flash.

Yes, many in the geek crowd are aware that H.264, since it is not open-source, is subject to licensing terms and eventually, a possible royalty. But, as a result of the popularity of the iPhone and the iPad, almost anyone on the web serving video streams has their video encoded for H.264, while also wrapping it up in a flash player for computers with Flash installed.

Almost nobody, especially mobile devices like Android and the iPhone, support WebM or Ogg  that Google claims it wants to use (yet other video codecs that are theoreticallymore “open”).

So, in favor of “open-ness”, Google’s scrapping support for a video format that may have some encumbrances in favor of one who’s legal liability – while reasonably clean – is utterly unknown, and keeping support for a video and interactive programming system (Flash) that is utterly, totally proprietary and closed. This aside from how much of a utter resource hog Flash has historically been (in all fairness, it is getting better).

The practical upshot is, everyone hosting video likely will not be doubling their storage space just to support two video codecs when they can just keep their single codec and use flash for browsers like Chrome that do not support H.264.

And in the meantime, the very “open” standards that Chrome strove so hard to support (along with Safari and Firefox) will be undermined.

All by itself, despite how much of a bully Adobe has been with it’s single-handed control of the Flash format, I would not have cared enough to change. I don’t care about the politics of the company, I care about the best tool for the job, and in the computer biz, that changes monthly. Chrome is a great browser. There are plenty of people without my use case for whom it will continue to be a great, and preferred browser.

But as for me, I’m writing this out of Safari.

Tragedy, and Reason

A few days ago, on the 8th of January of this new year, we saw a tragedy that blew through the national news. The basic story: A madman of no discernible politics shot up a crowd, aiming first for a congresswoman who was out in public, meeting her constituents and shooting her in the head, and then gunning down a number of others. Among the dead was a 9-year-old girl, Christina, who was, ironically, born on 9/11/01 but seems to have packed quite a wonderful life into the intervening years. The congresswoman, Giffords, is currently recovering, though how far she recovers is still a great unknown.

Sadly, instead of honoring and reflecting upon our dead, the recriminations began flying, with many of the accusations pointing at the “angry tone” of “right-wing” rhetoric, and some idiots on the right pointing back at the left to lay blame above and beyond saying “it isn’t so.” Other’s have been inspired by the high level of emotion to propose legislation banning mere things that in and of themselves cannot act, while others have proposed to ban “violent” talk about politicians as if free speech itself were to blame.

Everybody needs to get a grip. At times blame needs to be assigned, but this wild fury of blame-throwing (and even some of the justified defensiveness) is specious and dishonors the lives and memories of the dead.

First of all, the ultimate blame lies with the person who made the decision to act, to not only carry a weapon, but to use it as an instrument of murder vice defense. With the man who decided to pull the trigger and unleash his anger with deadly force. As John Stewart pointed out, no matter how toxic you believe the political discourse is, blaming the actions of an arguable lunatic on said political discourse is simply irresponsible, and painting your political opponents as murderers secretly reveling and wishing for the death of their opponents hardly raises the level of discourse, no?

Many people my age may remember the old, cheesy “Chick” comic tracts – extremely fundamentalist comic strips that talked about how rock and roll was evil, etc. This was also the time period where the Dungeons & Dragons role-playing game was controversial in christian circles because, supposedly, it lead to satanism and insanity. And yes, Chick argued just that. Many of us argued then that nutballs were simply nutballs, and if they didn’t latch onto D&D they’d find something else. Jodie Foster, or the Beatles perhaps. That is a fundmental human truth that has not changed.

It almost makes my posting from the 1st seem prophetic. You can tell some things about a person by who claims to be a friend or admirer, but only so much, as no-one can control who admires them, or why. We sure as heck don’t blame the Beatles for Charles Manson. 

The real measure of a person is who positions themselves as an enemy (and why), and who a person mutually treats as a friend – in other words, the company a person chooses to keep.

Ditto our shooter this last Saturday. An incoherent loner, a ranting person who described himself as wanting a gold standard, hated government, burned the american flag, liked Mein Kampf and the Communist Manifesto, and was waging a war on grammar. His fellow students and teachers were terrified of him and thought him dangerously unstable. If he had politics, it was somewhere beyond anarchist into chaotic.

Blaming people of a political party or faction because a lunatic chose to like some aspects of their political philosophy, especially when he believes many things entirely antithetical to that philosophy, and was not an accepted member of that group, is intellectual dishonesty of the first order. Does anyone seriously believe that a flag-burning lover of the Communist Manifesto who rants on grammar is a right winger? Painting people who as a matter of moral persuasion strongly believe in protecting innocents like Christina Green as encouraging this kind of behavior is a similar level of dishonesty. 

Given his favorite reading material, some have pointed blame at the left. Does anyone seriously believe this nut job was legitimately a member of any grouping on the left? Even the extremely radical terrorists of the last century like the Weather Underground and the Red Brigades needed their members to be reasonably sane.

Again, assuming you care about the civility of political discourse, this blame-throwing does nothing but poison said discourse unless the actual facts support it, and they don’t.

And while we’re at it, let’s be honest with ourselves about the discourse. Historically, the recent discourse is fairly tame, and sets no real high-water marks. Look at some of the political cartoons from the last couple centuries. Some may also remember  “Hey, hey, LBJ, how many kids have you killed today.”

And if you do think that using “sights” is unacceptably martial for political maps, then targets, the things you’re shooting at, are as well. This refers not only to Palin’s map, but to DNC maps re: republicans,  as well as democratic maps “targeting” Giffords in the 2010 primaries. If your standard is that shooting metaphors are wrong, you can’t pick and choose who you enforce the standard with without being at best partisan. Don’t argue that “targets” are better than “sights,” and don’t argue that crosshairs are actually “registration marks.”

Ditto with signs over the last decade at rallies. If a sign saying a president is socialist or fascist is unacceptable to you, then it’s not an “interesting metaphor’ when applied to a president you hate. Ditto with hanging in effigy. Movies about the assassination of the president are right out.

If you have a standard for what constitutes acceptable discourse, please apply it evenly. Address the idea and the policies, but not the person. Don’t hold people at fault simply because you hate them or what you believe they stand for.

Today is not the day to go into depth about politics being a “war” of sorts, complete with “campaigns”, where people decide who gets to write the laws that ultimately get enforced at the point of a gun. But one point must be made: the beauty of our system is at the end of the day, no matter what the results are, everyone feels like their point was heard, and goes home to try again the next round.

For that matter, today shouldn’t be the day we sit and argue about who is to blame, and I shouldn’t have to give a lesson on logic, civility, reason and the pointlessness or worse of painting those you disagree with as gleeful psychotics and idiots. It’s a tragedy, and these things, sadly, happen. As far as I can tell, the congresswoman, and many who were shot were good people who deserve our respect. As John Green, father of Christina said in this heart-breaking interview, this is the price we pay for living in a free society, and it beats the alternatives.

Let’s honor that, and deal with the lunatic as the time comes. As for everything else, well, standards are not something you exempt your friends from any more than you do your opponents. Let’s have some decency.

Busy

Worked up a multi-level core data schema last night for storing and handling data, and wrote a loader to allow importing files into the data store, allowing me to provide default data without hard-coding it into the app itself.

Core Data is an interesting technology. It has some weaknesses compared to SQL databases – there are no “uniqueness” tests built in, and everything is in memory for large data sets which is a bigger issue on memory-limited devices like the iPhone – but it also provides an excellent wrapper for managing data without having to write a lot of code yourself.

There are actually a number of decent tutorials, including Apple’s own documentation, but it’s not a “beginner” topic, and I’ve found that the only way I could get my own head wrapped around it was to actually work with it, so there won’t be tutorials coming soon.

Transmit

Transmit from Panic Software is my overall favorite FTP program, used to upload web pages to websites and do large file transfers across the internet. Cyberduck is also worth a look (and free), and Interarchy is also really a good program – though I was forced to stop using it due to unresolved issues (at the time) when accessing windows-based WebDAV servers. They’ve fixed those problems since. Since I’d already happily used Transmit for many years before that, and it currently fit my needs, I haven’t looked back.

Stellarium

Stellarium is a free “planetarium” program for your computer that allows you to look at the night sky at any given hour, at any given place in the world, at any given time rate, and point out the moon, constellations, planets, and major objects visible to the naked eye and binoculars. Slick, simple, and plain pretty to look at.

Version Control – git and OSX development

I really can’t do much more than recommend this quick how-to, and point out that I entirely agree. 

I dearly love time machine, and it has its place, but when it comes to tracking changes in anything more complex than a couple dozen lines of code, or more importantly, figuring out what changes you made and why, nothing beats having the convenient log of what you did and why that version control provides. The recommended gitX makes it pretty easy, though I find the branch merging to be a bit lacking (I prefer to use Tower).

Defining and Creating Objective-C Data Types

Learning Objective-C would be straightforward for anyone exposed to other languages, if one only wanted to learn Objective-C. You have your basic “C” data types, you have “objects.”

Further in, you have a library of “Foundation” objects that handle numbers, strings, and arrays. This is part of the standard “GNU” distribution and is not Mac-specific. The Root object is of the type “NSObject”

Even Further in, you have the Application Kit frameworks that handle UI elements and their needed features for programming on the Mac  (pasting, etc.). “Cocoa” includes both the Foundation and the Application Kit frameworks.

What I needed was a simple, clear-cut rule on when to use pointer nomenclature.

In C-based (and other statically typed) languages, you have to tell the program what kind of information is stored by a variable. So:

int myInteger;

myInteger = 1;

tells the computer that there will be a variable named “myInteger” used to access or manipulate data, to set aside room for that variable, that the variable will be an integer, and sets it to “1.” They can easily be combined into one statement:

int myInteger = 1;

Now, let’s look at objects. First of all, Objective-C, like Python and other object-oriented languages, refers to objects instead of accessing them directly, and so when you define a new variable for an object, you define it as a pointer. 

MyClass *myObject;

myObject = [MyClass alloc];

myObject = [myObject init]; 

This block of text creates a variable called “myString” that is a pointer to an object of the “MyClass” class. The second line calls the classes factory method to allocate the space for the class and create the basic structure of the object. The last line tells the object to initialize itself with any starting information needed so it can be used and referenced.

Why the curly braces? That requires a detour. Like all object oriented languages, objects have methods. For example, “car” objects have “drive” methods that do something when the car is driven. In Objective-C, you call these methods with the following syntax:

[object methodname]

so when I type:

myObject = [myObject init];

I am telling the “myObject” object to run its “init” method, and to assign the object it returns back to “myObject”. 

Also – name conventions. In Objective-C, Class, method, and variable names are written out in “camel case,” where instead of using underscores or other characters, descriptive names are put together with first letters capitalized. The very first letter of class names themselves are capitalized, while all other method and variable names, the first letter is lower case. Thus:

myObject = [MyClass alloc];

actually tells the object for the core class to create an instance of itself, and assign it to “myObject,” while:

myObject = [myObject init]; 

tells the actual object “myObject” to initialize itself, and repoint to its new self when done.

Also, messages can be nested. Since “alloc” returns a valid object, we don’t need separate lines. Instead, we can write:

MyClass *myObject = [[MyClass alloc] init];

Since [MyClass alloc] returns a valid instance of MyClass, it can then be passed a message to initialize itself (via “init”) before handing itself over to our new variable. This one-line methodology is the way you will almost universally see a new class object defined and created.

What about arguments? Arguments are delineated by colons. So, an init with one value passed in would look like:

MyClass *myObject = [[MyClass alloc] initWithArgument: argumentOne];

Simple enough for just one argument (I added italics to make it easier to tell which is which). “initWithArgument:” is the method, and “argumentOne” is the first value passed in. When dealing with multiple arguments, it can appear confusing. Each additional argument gets an additional label and colon. So, a message to implement a method with multiple arguments would look like:

[myObject doSomethingWith: firstArgument andWith: secondArgument andAlso: thirdArgument];

On one hand, this is almost completely different from anything you see in other languages – it reads almost like a normal sentence. That said, it allows you to create very descriptive method names that tell you exacly what it does, and what each value is needed for.

Also, the arguments can be standard “C” datatypes like integers, and they can also be other objects. As a result, if an argument for a method is an object, any method that returns the required type of object can be used as a parameter:

[myObject doSomethingWithObject: [myOtherObject returnAnObjectAsParameter]  ];

So, nesting works both for the object being passed a message, as well as for any objects being used as the parameters of that message.

All of the data types we’ve dealt with are statically assigned, yet, Objective-C is a “dynamically” typed language. This is because of one other data type I haven’t discussed yet: “id”. The “id” data type is a “generic” object pointer that can point to any type of object. It is most commonly seen when receiving actions from UI elements, or in other methods where the type of data is unknown, other than being an object. 

The “id” type also doesn’t use the pointer notation. As a result, unlike the examples we’ve seen above, a variable for an “id” is declared without the asterix:

id myIdObject;

Unlike static typing, any object of the “id” type can receive any message, and as long as the appropriate method exists, will do whatever the method instructs it to do. This is great for flexibility, but the downside is that you also can’t use key-value coded parameters, or any other convenience that relies on knowing the class type. You also don’t get error-checking when compiling the program. For the sake of speed and compiler error-checking, when possible, use statically assigned data types. You can often use a parent “super” class to allow some flexibility without sacrificing all of the error checking.

For some more good information on naming and programming conventions, you can look at part 1 and part 2 of the article “Cocoa Style for Objective-C.” 

Drobo – Stuff That Works

While not quite under “stuff I have at home” – but definitely under stuff I have my clients use – the “drobo” series of drive cases from Data Robotics, Inc. is a fantastic series of drive cases that do far more than allow you to hook up external storage or set up RAID arrays.

Most external drives are limited to the maximum size of one disk, and when your computer drives are near that maximum, backing them up with any sort of history you can dial back becomes a problem. Well, RAID is a solution to this kind of issue, but RAID is finicky to setup, and even more finicky to change or expand.

Hook up a Drobo, and slot in two drives. Now, if one of those drives fails, the other one keeps chugging with all of your data intact. All you have to do is yank the failed drive and slot in a new one, and it automagically rebuilds itself.

Need more space? Add a drive.

That’s it. No fuss, no muss, no reformatting or commands. Just. Add. A. Drive. The Drobo does all the work.

Need more space? Add another drive. Used up all your drive bays? Yank out your smallest drive and replace it with a bigger one. No need to shut it down, etc.

At every stage, the Drobo takes care of everything else.

We even had a client who’s Drobo had gone bad (the top bay failed) pull all the drives out under power, slot them into a new drive bay, and power it up. The drive rebuilt itself and is working just great.

Needless to say, I can’t recommend it highly enough. It’s expandable drive space for backups or storage, for people who don’t want to think about technical details.

Update: Over time this has become a recommendation I’ve reversed. At first, many of these worked, but over time flakiness with dealing with drives (even if you carefully shopped off the compatibility list) and network connectivity and access speeds drove us to finding other solutions.