Alexey L's Blog

This is a programming convention in Cocoa and Objective-C to make documents persist their data across sessions.

Every NSObject-derived class is allowed to override -init or define/override -initWithParams: method to complete initialization for a newly created instance. If there are more than one way to initialize an object one of the -initX: methods should be doing most of the assignments, while the others will delegate specialized cases of initialization to that one 'designated' -initX:, which will also invoke the [super -init].

Here is what it looks like.

- (id) init { return [self initWithSomething:@"something"]; } - (id) initWithSomething: (NSString *) aSomething { if(self = [super init]) { _something = [aSomething copy]; } return self; }

Note that -initWithSomething: is a 'designated' initializer and is responsible to -init the super class first.

But there is an exception to this rule.

Archiving works by defining pairs of -encodeWithCoder: and -initWithCoder: methods. This is also known as NSCoding protocol - a convention to make persistence possible across Cocoa applications.

So, when decoding a saved document Cocoa expects the NSObject-derived class to implement -initWithCoder:, which is a flavor of a -initX: method.

The first class in a hierarchy of classes derived from NSObject will have its -initWithCoder: call [super -init] because NSObject does not implement NSCoding protocol. It will not call any other -initX: initializer even if there is one explicitely defined.

All other classes that are derived from a class with NSCoding protocol will have to replace [super -init] with a call to [super -initWithDecoder:]. This ensures that super properties are deserialized correctly. This breaks the -initX: pattern of 'designated' initializer.

In NSObject-derived class that implements NSCoding protocol:

- (void) encodeWithCoder:(NSCoder *) encoder { [encoder encodeObject: [self something] forKey: @"something"]; } - (id) initWithCoder:(NSCoder *) decoder { if(self = [super init]) { [self setSomething: [decoder decodeObjectForKey: @"something"]]; } return self; }

In classes, derived from other NSCoding classes that sit somewhere in the middle of hierarchy:

After downloading and opening .DMG file (packaged application) click the Xcode icon. It runs as a fully functional application, and that is one way to go about using apps on Mac.

It actually feels natural. Apps are supposed to be contained and updated easily by just replacing .DMG files, while user settings are stored elsewhere on the system.

To install permanently, drag the app icon to 'Applications' icon. This is installation in classical sense.

Also, shortcuts to take screen shots on Macs:

Command+Shift+3: screenshot of the entire screen, saves to desktop.

When people don't have access to resources, their behavior is difficult to measure, they cannot arrive at appropriate conclusions.

The range of your thought is limited by a dominant value of your society.

Once people are free, mentally, of debt, obligation, servitude, then they can see new horizons that they've never even dreamt possible before.

... No courses to exploit or abuse any other human being. All repetitious jobs are for machines. Man has to be free to pursue the higher ideas, the higher possibilities.

Depravation, poverty and crime have no basis in an engineered society.

Superstition prevails whereever ignorance prevails.

Asking "how much does it cost" instead of "are there resources" is an outdated way to live a life. Money is a barbaric invention in a scarecity environment.

Live a life by solving problems, not by being a dollar slave.

Last week I had a request from a recruiter to submit my answer to a technical pre-screen question. They've asked to provide code snippet, so that's what I've done. The question had two parts in it, but the second part was a generic and quite boring where I had to explain a few development nuances.

This is not the best answer or solution, I've spent more than a couple of hours on this. I just did not really care about the job, it was not what I would ideally want to be doing.

Two-part pre-screen quiz follows. First the questions and then my answers. Try and guess who the employer was and what the job was about.

1. Write a method in C# (doesn't need to be an entire program) which takes in a file path (like c:\SomeFolder) and traverses that folder and all of its sub-folders to find any files with duplicate names (for example, “readme.txt” and “readme.htm” are commonly occurring names).  Print out any file names that are duplicated.  You can use anything available in .NET and you’ll specifically want to use the File Info and Directory Info classes in System.IO.  (note that Directory Info has a flag - System.IO.SearchOption.AllDirectories - which causes it to return all directories recursively… please do not use this, but implement the traversal yourself).  You should spend less than 20 minutes on this. 2. Describe your experience with automated unit testing… what are some of the rules/principles/patterns you follow when writing your code so that you will be able to write automated unit tests for it later?

private List<string> allFiles = new List<string>(); private List<string> duplicates = new List<string>(); /// Entry point for recursive search of duplicate files in a folder. public async Task<List<string>> GetDuplicatesAsync(string folder) {     allFiles.Clear();     duplicates.Clear();     // Initiate recursion     await Task.Run(() => GetDuplicateFiles(folder));     return duplicates; } /// Iterates over provided folder content and finds duplicate files. /// Recursively finds duplicates in each subfolder. private void GetDuplicateFiles(string folder) {     var dirFiles = Directory.GetFiles(folder);     if (dirFiles.Length > 0)     {         // If prior iterations have found files - begin lookup         if (allFiles.Count > 0)         {             // New files are not added to allFiles immediately to avoid             // their lookup in this iteration             var newFiles = new LinkedList<string>();             foreach (string filePath in dirFiles)             {                 string file = System.IO.Path.GetFileName(filePath);                 // This file name may already have been detected                 if (!duplicates.Contains(file))                 {                     // Finally check for a duplicate                     if (allFiles.Contains(file))                     {                         duplicates.Add(file);                     }                     else                     {                         newFiles.AddLast(file);                     }                 }             }             allFiles.AddRange(newFiles);         }         else         {             // If this is a fresh start - the allFiles will be empty             dirFiles.ToList().ForEach(f => allFiles.Add(System.IO.Path.GetFileName(f)));         }     }     var dirFolders = Directory.GetDirectories(folder);     if (dirFolders.Length > 0)     {         // Recursively iterate subfolders         foreach (string folderPath in dirFolders)         {             GetDuplicateFiles(folderPath);         }     } }

I've been using async/await for some time now and I do find it very clean and tidy compared to pure TPL approach. But there are a few caveats that I found quite annoyingly hard to remember, or rather these things were not readily discoverable.

And now at my n-th iteration to dive into async world of WinRT with C# I will record in concise form some of the tips for future reference.

Example:

public async void PointerPressedAsync( object sender, PointerRoutedEventArgs e ) { // top-level async operation // 1. context is captured // 2. async context timer is incremented // 3. initiate await for long-running tasks // 4. async context timer is decremented // 5. exit method, but context is still captured // 6. schedule callbacks in the same way as for all other types of async methods. }

1. SynchronizationContext flavors

These are classes with instances that help align asynchronous tasks back to original threads of code. To clarify, async long-running tasks usually end with callbacks to original code, but not exactly at the point of task invocation. Callbacks are serialized with the rest of original code to run in the same thread (usually for UI). If thread is occupied, the context will schedule all outstanding callbacks to run in FIFO queue order. And this is the case with classic UI applications (WinForms, WPF, WinRT), but a bit different for WCF and ASP.NET.

More about SynchronizationContext flavors is here.

2. Asynchronous operation count

This is maintained by SynchronizationContext instance and keeps track of outstanding async operations. This is done by a relatively simple increment at the moment the context is captured (awaiting for an async task), and decrement when callback is scheduled at the task completion.

3. async void vs async Task

These two methods capture external context in the same way and schedule their inner async callbacks (state machine states) to run in those contexts, unless specified otherwise (by using ConfigureAwait(false)).

The difference is that async void will increment/decrement asynchronous operation count (see above) at the method's start/end, that is while its initial async state runs. This is useful when application code does not really need to keep track of exact moment when async operation completes.

These async void operations are also known as top-level, not requiring outer caller methods to be declared async. In fact the only possible async signature for the top-level user code event handlers is async void.

This works well with other legacy libraries or external code that accepts event handlers. In this case client code with async callbacks can replace void with async void.

Note that top-level method needs to take care about catching all exceptions from awaited tasks.

More great insights into one async vs another are in MSDN Mag forum and in Jerome Laban's blog.

I was looking for a neat styling of code snippets in my posts and found the Google's Prettify to be a good solutio for now. The following setup instructions are an extention on the Snippets of Code.

1. In your blog settings (cogwheel at the top) click the blog in the left panel. Click Theme Customize. Once theme opens click the Edit HTML. This opens an HTML editor.

2. Find the closing </head> tag and insert the wollowing snippet in front of it.

<!-- BEGIN: Code Syntax Highlighting --> <script src="http://code.jquery.com/jquery-latest.min.js"></script> <link rel="stylesheet" type="text/css" href="http://google-code-prettify.googlecode.com/svn/trunk/src/prettify.css"></link>  <script src="http://google-code-prettify.googlecode.com/svn/trunk/src/prettify.js"></script>  <script>     function styleCode() {         if (typeof disableStyleCode != 'undefined') { return; }         var a = false;                 $('code').each(function() {             if (!$(this).hasClass('prettyprint')) {                 $(this).addClass('prettyprint');                 a = true;             }         });         if (a) { prettyPrint(); }     }     $(function() {styleCode();}); </script> <!-- END: Code Syntax Highlighting -->

3. The code above finds all <code> tags and sets class="prettyprint" attribute. Click Update Preview and then Save.

4. Now edit a post and insert a code you want highlighted. Now click HTML button while you are still editing the post, find the newly inserted text and embrace it into a pair of <pre><code>...</code></pre> tags. Example:

       private string path;         public string Path         {             get { return this.path; }             private set             {                 this.SetProperty(ref this.path, value);             }         }

For a code-to-HTML conversion that produces standalone HTML with formatted code there are a few online tools available:

https://gist.github.com/

http://www.manoli.net/csharpformat/

http://hilite.me/

http://tohtml.com/csharp/

Normal tag filters will retrieve posts in reverse chronological order (most recent on top). Example:

http://staff.tumblr.com/tagged/events

To retrieve in chronological order (oldest on top) use the extra postfix /chrono:

http://staff.tumblr.com/tagged/features/chrono

Standard functions are there - post, reblog, delete post etc. But no methods to create or remove entire blogs.

Tested it and it recognizes blog origin, allows reblogging on a secondary blog (if there are any) or fails if it detects circular reference.

I find it a promising feature for creating threads sorted in either chronological or train-of-thought order.

Reblogging your own posts is possible and here are the details:

http://tumblring.net/how-to-reblog-yourself-on-tumblr/

From that link...

How to Reblog Your Own Post on Tumblr

Right Click on the following bookmarklet link – REBLOG YOUR OWN POST ON TUMBLR – and choose “Bookmark this link” (I didn’t see that option in the Chrome Browser, so use Firefox or Explorer)

Now, once you are on one of the posts of yours that you want to reblog (not the dashboard, but the article itself ) Click on the Reblogging bookmark you just saved and you will be taken to the reblogging edition screen.

Actual link:

javascript:(function()%7Bwindow.location=%22http://tmv.proto.jp/reblog.php?post_url=%22+window.location%7D());