The first step is recording the data. There are many ways to do this. Databases have traditionally been a great way. NoSQL databases with their loose document format are interesting. The second brain methodology uses documents or notes to contain the same thing. And while these documents can be formatted in things like Markdown and have front matter for categorization, much of the data is contained in the raw text which means a human has to parse and read it.

Before you expect this post to come to some epic realization, tl;dr; I still don’t have one. This post is about the methods out there I’m considering for sorting my life.

Option 1: SQL

I’m not a fan of no SQL databases. From my point of view, if you are going to create data to exist in a place that is typed, loose document formats make comparing and reading things hard. So structured data is better, hence SQL.

Pros:

• The data is structured from the start
• There are many different options for which SQL platform to use and many of them are interchangeable so there are options.
• Things like normalization define best practices for working with something like this, so you don’t have to develop them yourself.

Cons:

• You need to run a server somewhere.
• It is not easily human decodable.
• You need to learn to use SQL to really be successful and joins are fun (and hard).
• Because structure is required you have to define it up front.

Option 2: Markdown

This is honestly what I’m currently using in my second brain with Obsidian. This may be the best of all worlds. It has the notion of storing structured data in front matter, and throughout the document with special tags. Much of the document remains readable in sentences, but it is in loose format and you have to create and maintain your own formatting standards.

Pros:

• Format is loose so you don’t need to stress about it.
• Much of the notes are human-readable.
• There are many tools to convert markdown to the web for sharing.
• Cost of starting is very low.

Cons:

• Because the format is loose, the responsibility lies on the creator to maintain the structure desired.
• The organization of individual documents is also important.
• Search is only as good as you are at searching and remembering.
• It’s easy to end up with a mess of documents.

Option 3: Stricter document format

This category contains things similar to markdown but with more structure. This category fits things like JSON, YAML, and TOML. This is following the Pragramtic Programmer guideline of storing things in the text but putting some structure behind it. Some of these formats are more readable than others.

Pros:

• Easily computer parsable.
• More human-readable than a SQL database

Cons:

• No official typing.
• Need to use a validator to confirm you have a valid document.
• Nothing requires the structure like a SQL Table so searching could be difficult.

Summation

I don’t have a conclusion. I’m still thinking, but these are interesting options of how to start really putting the data together. Our lives are full of data, it’s a shame when it gets lost or mislabeled or put in a place where we can’t find it. Hopefully, I’ll start putting together something more useful.

The problem. I’m looking at my address book and I want to iterate through my contacts. I started by looking at ABAddressBook, but it turns out that technology has been depricated. Then I started looking at CNContactStore which is the new hotness. There are several fun methods on that object including unifiedMeContactWithKeys which is pretty cool. It only returns my contact, not all contacts, but at least I was able to get it work. There is a similar function called

1

func unifiedContacts(matching predicate: NSPredicate, keysToFetch keys: [CNKeyDescriptor]) throws -> [CNContact]

You try to pass in the truthy predicate and it rejects it. You need to actually use the

enumerateContacts() method. Some examples mix strings and other types with keys and that causes problems. Just using a list of Keys worked. Here is the final code that worked:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

//
//  main.swift
//  contactsexport
//
//  Created by Zachary Cohen on 12/23/22.
//

import Foundation
import AddressBook
import Contacts

print("Hello, welcome to the AddressBook Scraper")


var store = CNContactStore()

store.requestAccess(for: .contacts, completionHandler: { (access, accessError) -> Void in
    if access {
        print("access granted")
        print(access)
    }
    else {
        print("access denied")
    }
})


let nameKeys = [
    CNContactNamePrefixKey,
    CNContactGivenNameKey,
    CNContactMiddleNameKey,
    CNContactFamilyNameKey,
    CNContactNameSuffixKey,
    ] as [CNKeyDescriptor]

let allContactKeys = [
    CNContactNamePrefixKey,
    CNContactGivenNameKey,
    CNContactMiddleNameKey,
    CNContactFamilyNameKey,
    CNContactNameSuffixKey,
    CNContactOrganizationNameKey,
    CNContactDepartmentNameKey,
    CNContactJobTitleKey,
    CNContactBirthdayKey,
    CNContactNicknameKey,
    CNContactNoteKey,
    CNContactNonGregorianBirthdayKey,
    CNContactPreviousFamilyNameKey,
    CNContactPhoneticGivenNameKey,
    CNContactPhoneticMiddleNameKey,
    CNContactPhoneticFamilyNameKey,
    CNContactImageDataKey,
    CNContactThumbnailImageDataKey,
    CNContactImageDataAvailableKey,
    CNContactTypeKey,
    CNContactPhoneNumbersKey,
    CNContactEmailAddressesKey,
    CNContactPostalAddressesKey,
    CNContactDatesKey,
    CNContactUrlAddressesKey,
    CNContactRelationsKey,
    CNContactSocialProfilesKey,
    CNContactInstantMessageAddressesKey,
    ] as [CNKeyDescriptor]

do {
    let contactStore = CNContactStore()
    let me = try contactStore.unifiedMeContactWithKeys(toFetch: nameKeys)
} catch let error {
    print("Failed to retreive Me contact: \(error)")
}

do {
    let contactStore = CNContactStore()
    let fetchRequest = CNContactFetchRequest(keysToFetch: allContactKeys)
    try contactStore.enumerateContacts(with: fetchRequest) { con, response in
        print(con);
    }
} catch let error {
    print("Failed to retreive Me contact: \(error)")
}

I’m still working on the project and there is bunch more to do this, but this is a start and figured it was worth putting out there.

Start with the UI

My first big tip is to start by creating the UI. One of the greatest things about Airkit is its ability to rapidly prototype interaction with your end users. Create the app quickly and show it to users. Often there are use cases that are missed when initially thinking about a project and this rapid prototyping brings them out.

Variables and Types

Create types for your complex object. If the data is going to be stored in AirData, then I create an AirData object, but Custom Types are good to explain what you expect the data to look like. Knowing the format of your data is helpful when using it to fill in form details data ops.

Naming is also important. Tables are capitalized where as instance variables are lower snake case. Profile constants can be capitalized snake case. Following this convention will make things clearer to read, but is not enforced by the platform. It is useful for understanding how variables are used across the app.

Scoping of variables is also important. In general, the goal is to minimize the scope of variables as low as possible to allow for more reuse of your components. That means if it is possible keep your variable on a web page then do, because it will come when you copy and paste the page. If you move it up to the flow level you will need to copy the entire flow together to have access to the variable. The downside of keeping everything at the page level is that you might end up passing it in to a bunch of pages, which is also not good. That is the trade off.

Also of note, because of some legacy notions, variable scopes are a little confusing:

Variants and Themes

While each individual element has its style properties in the web builders inspector, the best practice is to store things on variants for each type. Even if the variant is only used once. This gives clear intention to the way you are styling each component and all styles can be managed directly through Theme Builder. It allows them to be reused as well.

Getting Help

There are plenty of ways to get help with Airkit. Start with the support site and if you can’t find the answer there you can always post a question on the community board. If that doesn’t work you can send an email to support@airkit.com.

What you may not understand is that the world of email is rather confusing. Basically, the email that comes over the wire is presented to you by your email client and where email gets very confusing is that there are a million different email clients. You probably use more than one. If you look at your email on a mobile device and on a computer that is two different clients. Then when you think about 3rd party clients and even GMail which renders in a browser, you have a client which is actually a client within a browser.

Because of the various numbers of email clients and security concerns, while the web has advanced, email was still written and styled like the early 2000s web. This means table layouts, no real stylesheets, and things like the center tag from way back in the day.

When I left Salesforce, I was hoping that my email wondering days were behind me. Well, for the most part, they are, but one common thing our clients need is to send emails to their clients. Bringing me back to writing stylized email HTML like the 2000s in table layouts.

Despite being very forward-thinking when it was first created, Gmail is usually the hardest client to style for. It’s not really their fault. They are presenting your email in a web browser and they have to be secure on their side of things. I don’t begrudge them thinking about branding and security. Still, things are starting to change and Gmail is now supporting some new things:

• CSS Support
• Schema.org Proposals

Gmail isn’t the only client, though. Because of this, much of the email stuff is still being done with tables. This is pretty challenging for those of us who have spent a bunch of time learning to do things right in CSS (though, to be fair, I’m not the best at CSS).

The association for me feels a bit like the Cobal programmers who were needed to fix all the old code used before the year 2000. Granted, we have better tools for conversion, but this does feel a little archaic.

A Good resource is:

https://www.udemy.com/course/html-email/ – a good course on how to work through HTML email.

I’m learning more things as I go through this process. So far, I’ve learned that not all divs are respected and also that you have to use a capital M in margin for outlook. You also cannot use SVGs in email, you must use PNGs. More lessons to come as I dig through this project.

I’m trying the Nitro Cold Brew coffee from Stumptown that they just started carrying at Planet Granite. It is tasty, but I like the regular cold brew better and will be sticking to that in the future. Still, I do love coffee.

Grateful List

I was listening to a podcast the other day, I believe it was Finding Mastery with Ariana Kukors: Swim. And they were talking about gratitude practice. The part that really stuck with me was that practicing happiness is really hard. Being happy is a by-product of the world around and the best way to approach getting that feeling may be through practicing gratitude. I’m going to try and say three things I’m grateful for each day.

1. I’m so grateful that we as humans discovered coffee. It has a profound effect on my life and while I only drink about 2 cups a day, I love it.
2. I’m grateful that I can afford to take as many pictures as I do now. I love photography and there was point when I was in college when I felt like it was too expensive. Thankfully I can now afford great gear and enjoy using it.
3. I’m very grateful for my climbing community. Yes, I don’t see as many of them as much as I used to, but I love having a second home at the climbing gym. It is more adult that my cheer community (not that I don’t appreciate that as well), and much closer to my house.

Reading Code

I spend a lot of my time reading objective-c code for work. Reading the basic syntax is pretty easy, but understanding what is going on in someone else’s code has always been relatively difficult for me. I’m not sure how everyone else does it, but the way I tend to read code is to go through a live example of the code and see how variables are manipulated. I like to track a path from a point I understand to a point I need to discover. The larger the piece of the code the harder it is for me discover the flow and the process.

The best analogy I have to this process outside of code is my attempt to read the Odyssey. I moved around a lot as kid and didn’t get to read greek theology in school. I have tried to pick up post school, but understanding the Odyssey or the Illiad has been very hard for me. I can read the words and understand the basics of what’s happening, but I’m not sure I can see the forest through the trees. When you are in class, you have a teacher and class to discuss the book with. The concepts in the book are discussed and you collectively discover what is going on.

When reading code, the teacher/class is akin to being able to talk to developer who originally wrote the code. Sometimes they are sitting right next to you. Sometimes they are downstairs or close by. Sometimes they are phone call or email away. Sometimes there are cliff notes in the form of a really good tutorial or ReadMe. Most of the time, though, you just have figure it out on your own. If the code is written using some common conventions (like a restful api, or common design pattern), it can be easier. Sometimes the code is all over the place and impossible to discover.

Yesterday I was working on understanding MGSwipeTableCell. It’s a pretty well built piece of code, but still rather confusing to figure out for me. I figured out what I needed to, but only after a couple hours of debugging. I wish I had done a better job reading the original piece of code from the beginning.

Here are some of the factors that made this problem more difficult:

• Our one custom cell was in a UITableView of regular cells
• The fonts for each of the items in the cell were pretty consistent with the rest of the table view
• Like every other cell, we wanted to it to be indented based on cell.separatorInset

I looked at several ways to approach this. I tried using a custom table view. I tried subclassing a UITableViewCell. I finally landed on trying to override the tableView:willDisplayCell:forRowAtIndexPath: and it is worth explaining why.

First approach was getting a custom view in place. I turned this approach down because my view really wasn’t that custom. It was actually a tablevViewCell. It actually looked remarkably close to a standard table view cell. It had a text (in this case an NSAttributedLabel), and a detail text (the amount). Putting in a custom view would have required hard coding the layout to match the rest of the cells in the table and that seemed wrong. I also ran into a bit of confusion around getting my separator to be the correct size.

Then I tried subclassing the UITableViewCell. I know subclassing is frowned upon, but I only wanted to override layoutSubviews. I took the accessory view and tried and moved it to an offset of the tip label. I ran into a problem where the textLabel and detailTextLabel font color was being set to gray by the fact that I had userInteractionEnabled set to NO. If that sounds crazy, it should. Here’s a picture of what I saw:

After overriding UILabel and trying to see who was calling setColor on it, I came up with nothing useful. This felt like the wrong approach.

Lastly, I looked at tableView:willDisplayCell:forRowAtIndexPath:. When you first get into this method, the cell’s subviews frames have yet to be calculated. I called [cell layoutSubviews]; which is costly, but get the dimensions I needed. Inserting the the editView after the label is then simple math. Here is what the code roughly looks like.

Gist

The downsides of this approach is the double rendering of the cell, but the benefit is that we get to keep our cell as close to factory as possible. In our case, we have one custom drawn cell on the page, so the performance doesn’t take that big of a hit.

There are other approaches to this problem, namely Mensa Smart Tables, but including another library seemed like overkill for what we needed.

I have a method that is trying to do a TryUpdateModel(model, new[] {"prop1", "prop2"}); call and my model wasn’t getting updated. I checked out the associated FormCollection and sure enough my values were in it. The problem was in how I was defining my model.

1
2
3
4
5

public class MyModel
{
   public int prop1;
   public DateTime prop2;
}

Can you see the problem?

It took some digging, but it turns out that prop1 and prop2 as defined above are not properties. They are public members of the class MyModel. In order to be properties you need to assign them getters and setters like so:

1
2
3
4
5

public class MyModel
{
   public int prop1 { get; set; }
   public DateTime prop2 { get; set; }
}

My frustration is that prop1 and prop2 from my perspective as a consumer don’t really change with the new definition. It seems weird I should have to do that. I’m a new C# programmer and I totally believe that in 3 months more of working with this language I might become a purist and understand the reason to have these things behave differently, but for someone new to the language this isn’t the most intuitive approach.

Firstly, on my old computer, I used to be able to hit the a keyboard combination to get my machine to sleep. I believe it was something like Cmd – Shft – Eject. Well, the Microsoft keyboard doesn’t have Eject. So I’m out of luck there. It does, however, have a set of buttons reserved for favorites. So I decided to code up a little AppleScript and bind it to one of these keys. Here’s the script, and I just saved it as an editable application. Then you can go into the preference pane for the keyboard and assign the whichever key you want to this script. Good luck.

1
2

tell application "finder" sleep
end tell

MFC is Microsoft’s old Window framework. Basically it is an object oriented wrapper around the traditional Win32 programming environment presented by Microsoft to help develop windows. Win32 is many years old, and so is MFC. Microsoft’s new frameworks, .NET and WPF (Windows Presentation Framework) are supposedly better than MFC, but I have yet to play with them.

MFC has tools for many different types of controls, from buttons to dialogs, windows, and menus. MFC allows the user to create the button, override some basic functionality, provide message callbacks and otherwise manipulate the application. Buttons are particularly interesting because the base class for buttons actually provides a ton of functionality for many different types of buttons. From this one class, you can get push buttons, check boxes, radio buttons, owner draw buttons (the programmer handles the rendering of these buttons), etc.

I have several problems with this class design, but today I just want to talk about my gripe with Radio Buttons. The term radio button comes from the buttons on old car radios, where only one button could be pushed at any one time. Radio buttons on a computer form, are by definition grouped with other radio buttons so that only one in the group can be selected at any one time. Any time a user selects another button in the group, the previously selected button should become unselected.

Taking this even further, logically, you should only use a radio button in certain situations. You have several options, usually less than 10, and you want the user to select from one of them. You should be able to have a default option set, and this choice should somewhat make sense. This functionality is very similar to a drop down box. In a drop down, you have a bunch of options (please put them in some order), where the user should select only one item. The difference in use between radio and drop downs depends on your application, but in general, you can put more items into a drop down. Drop downs will take up less screen real estate, but not all the choices may be obvious to the user, and sometimes the user may select the first option that seems relevant rather than looking through the whole list. In a radio group, all the options are present at the start.

This brings me to my gripe. MFC radio buttons are just the same as any other CButton. The way you define that a radio button is a radio button is by passing a style flag that is either BS_RADIOBUTTON or BS_AUTORADIOBUTTON. The difference is that auto radio buttons will look to be part of a group. This group is defined by ORing the BS_AUTORADIOBUTTON style with WS_GROUP for the first element of a group. All subsequent radio buttons will be part of that group until you create another WS_GROUP.

This upsets me because radio buttons in a group are associated with the other buttons in that group. They shouldn’t just be loosely coupled like this. It puts a lot more responsibility on the programmer to understand how the grouping is done. If you look at the picture above, you will notice it is from my Mac. In Interface Builder, Apple does not provide you with individual radio buttons, it instead provides an object called a “Radio Group”. This group is a collection of radio buttons that handles all the magic I wish existed in MFC. To be fair, Apple’s implementation is pretty new, they have redefined the way to create code on the Mac no less than 8 years ago with release of OS X. Microsoft’s MFC is much older than that and they have new technologies out there which probably better handle this problem. My issue is simply that I am working with legacy code here, and am incredibly frustrated by the lack of UI thought that went into designing this library in the beginning.

The problem was that as I wrote out the code I made a typo on the code I was writing. I wrote something like the following snippet:

1
2
3
4
5
6

     // ... 
     int x = pixels2OtherUnitsX(20);
     int y = pixels2OtherUnitsX(23);

     // ...

If you look closely you will see that I’m using pixels2OtherUnitsX() in both cases, where I should probably be using pixesl2OtherUnitsY() in the second case. Oops.

What do you know, my image didn’t render correctly on screen. I had recreated the bug that someone said was out there. Now all I had to do was figure out where in our production code the bug was. I spent way too long looking around for the problem.

Lesson don’t be so blinded by your desire to find a bug you miss one that is right in front of your face.

So I was working on a exercise where I needed to write some sort of state machine.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

enum STATES{
  STATE_1 = 0,
  STATE_2,
  STATE_3,
  ...
};

/* ... some other code ... */

switch(state) {
case STATE_1:
    // Do something
    state = STATE_2;
    break;
case STATE_2:
    // Do some other stuff
    state = STATE_3;
    break;
case STATE_3:
    // Do the last state of stuff
    // This code never gets called.
    break;
}

In this code STATE_3 is never reached. The code for the enum was working fine, but the state wasn’t being reached. I went over this for a while, until I found out the problem.

1
2

bool state = STATE_1;

The assignment for the state variable had been left over from a previous implementation of the code, and when you set the Boolean value for state = 2;, you get 1, which is true.

Now I don’t expect anyone to be as silly as me and make this mistake, but just in case, learn from my lesson.

The sad thing is, not many of these books actually publish a table of contents online. At the time when I was first searching for books, one of the notable series that didn’t publish this was Head First Labs. They have since changed their ways and publish a PDF version of each books TOC on the individual book page. Another good example is the new Hillegass book. While this is a great book, and I was going to buy it, with, or without a look at the TOC it would still be great to see the TOC, so I knew what I was purchasing.

There is another one that really drove me up the edge. I purchased the first edition of Bullet Proof Web Design, and thought it was a GREAT book. While Dan’s site now has an updated TOC, it didn’t when the book first came out, and the publishers book page does not list the table of contents, even though they will give you chapter 1 for review. The other problem with this book, is that even at the time of this post, there is no real mention about what has been updated in the second edition of this book. Now, I definitely see the cause for someone new web design to buy this book, but why should “I”, a reader of the previous edition shell out another $25 for this one?

This is just another instance of not giving the customers what they need. How hard is it to publish your TOC? It is a simple list element on your webpage. You aren’t giving out anything that special, just giving your customers an idea of what they will be purchasing. That is rule number 1 in sales: give the customers what they want.

https://zacharyc.com/projects/cheer-resource/

Keep in mind that this is still a rough sketch, and this not what I do for full time employment. This is a “project”, or something I work on for fun. More details to come in the future. For now, I’m just excited to have set up a basic code base and database structure.

The question is, in straight C, will this work:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct point_t {
  int x,y;
} Point;

int main(int argc, char **argv)
{
  Point a,b;
  int c[4] = {1, 2, 3, 4};

  b = c;

  printf("b(%p) is now b[x] = %d, b[y] = %dn", &b, b.x, b.y);

  return 0;
}

In C++ this works no problem. Structs are teated like classes where all members have public scope. Assigning one struct to another simple implements the copy constructor that is created by the C++ language, but what about straight C?

Well, like I said the answer is the obvious one, IT WORKS! The reason this originally confused me was because you CAN’T do this:

1
2
3
4

   int a[4] = { 1, 2, 3, 4};
   int b[4];

   b = a;

Why not? The compiler knows how big each of these integer arrays are. If you run sizeof(a); and it will give you the same thing as sizeof(b);. Copying an array is as simple as copying over the bytes (bit for bit), using memset() or something similar.

The reason structs work and arrays don’t is simple. Basically we are doing a type check on the object. If the object is a struct of defined type, we know how to do an assignment because we have the size. If the item is an array of integers, we would have to do a size comparison and the compiler doesn’t do that.

Okay, so I hope that explains the obvious, good luck.

Sometimes, however, we make a bad decision and write what we would call bad code. Finding the right balance of good is hard, but seeing bad code is easier.

I was talking to a friend the other day about an assignment at work. The story told was enough to terrify me into writing this blog post. Basically, the developer was working on some code in python. They were making a method call and getting back an exception which printed out

rc = someMethodCall()
…
# returned:
“error: no error”

Code like this really frustrates me. The programmer who wrote the call is returning an exception with “error: no error”, basically the error was that it executed successfully. I don’t like this approach for several reasons:

1. If you want an exit status, use a return code.
2. “No Error” is not a type of error, so there shouldn’t be a thrown exception for it.

Okay, so I only have two reasons why you shouldn’t do this, but I feel these reasons are compelling.

Now, I’m not saying anything about the developer, perhaps the “No Error” call might be due to some legacy code, but still, if you have this, write a wrapper. Just as if you were the person printing the shirt above. If you are a printer, you should check the quality of what you are printing. Say they did send you the text incorrectly, with the words “Competion”, shouldn’t you look at the message before you blindly attach it to a t-shirt?

I recently finished reading Head Rush AJAX and would like to share my comments on the book.

This book is written by Head First Labs and is the first of the series I have read. I picked it up because of a recommendation from a friend. I remember looking with disdain at the books in the series when I had seen them on the shelf. I remember thinking, “They look so elementary, we don’t need another ‘For Dummies’ series”. I, like most computer people, have picked up and read a “For Dummies” book, but after you get through your second, they really loose their allure. My first three technology books were from that series, and I have never committed to reading another one.

When it comes to Head First AJAX the phrase “Never Judge a book by its Cover” has never been more true. If you look at the cover and see the guy doing an one handed handstand you might not want to take the book seriously, but this is a serious book with a serious introduction to a very new and very powerful technology.

About the Reader

It is important to understand the perspective of this review. When I picked up this book I head been reading the Javascript: The Definitive Guide. This is the canonical book on Javascript, and while it is very informative it is not a very practical straight read. I wanted to give up after about 100 pages, this book offered a quick alternative so I picked it up.

I’m a strong HTML and CSS programmer, I have worked with various web technologies like Rails and PHP. I wouldn’t qualify myself as an expert, but I’m no stranger to web programming. However, up until recently, I have had one GAPING flaw in my resume when it comes to web work, I have had little to no knowledge of javascript. I used a snippet of javascript back on a website I had written many years ago that responded to an onHover event to replace an image, but that was the extent of my real JavaScript experience. Realizing this hole and having some time on my hands I set about fixing it.

Book Content

This book covers the following topics:

• Intro to JavaScript
• Discussion of why there is a need for AJAX
• Basic PHP on the web server side
• Introduction to Web Security (defending against SQL injection)
• The Document Object Model (DOM)
• Introduction to JSON

Each of the topics in the list above is described using both pictures and instructions. There are several cornerstones to the Head First approach, but two of these really stuck with me. Firstly, everything that is important is repeated. Secondly, information is presented in both a textual and graphical format. Text is placed next to pictures to get your mind to remember it. This is EXACTLY how I learn, so this book worked great for me.

Criticisms

I really liked the book, but there are a few areas where I felt like the speed of the book was too fast and some areas where I felt they could have used improvement. The last chapter is when they first introduce JSON. The introduction is a bit rushed, and they use the blanket “eval()” statement in javascript to execute the JSON code. Being a traditional programmer, I’m always apprehensive of using an eval function, especially in the case where are receiving the code to eval from a response object. There is no talk about the security risks of using this function until the Appendix.

My second issue is the discussion of frameworks doesn’t occur until the Appendix. While understanding the fundamentals of AJAX is very important, in practice frameworks are more practical then rewriting code that already exists out there. There is a discussion of frameworks and how to use them, but that isn’t until Appendix I.

In short, Appendix I is not an optional read. The contents of this Appendix I feel are completely necessary in order to actually start using AJAX, and the fact that it is listed as an Appendix is misleading.

Conclusion

I would strongly recommend this book to someone in my position. It gave a great introduction to AJAX for someone already familiar with web programming. I could see how users without any experience in web programming might get lost by this book, but it was PERFECT for me. I have since purchased my second book from Head First Labs, and will hopefully write a review of that title shortly.

People at Omni recognized a good nitch for a better product and so began to create a new product OmniFocus. This product would be directly geared towards the kinkless users and perhaps pick up more users in the wake of the new GTD craze. As of this post, I’m aware that omni has sold over 11,000 licenses for its application, which just hit version 1.0 yesterday (no, they didn’t make 11,000 in a day, they have been selling the product in beta for a couple of months).

Now, I’m a big fan of Omni products. I swear by Omnigraffle, and there are some interesting uses for OmniOutliner that sometimes make it more useful than excel or numbers (it is much FASTER than numbers). However, I have been using OmniFocus for a little while and am a little disappointed that they have released version 1.0 in the condition it is in. This app feels like it is so far from done, that I can’t understand how it can be at revision 1.0. Also, they up until announcing version 1.0, they were calling the builds alpha builds, which leads me to believe that this might be a premature release.

Here is a list of some of things that are frustrating me with the app:

• There is a “Clean Up” button on menu bar that you have to hit in order for your tasks to disappear. I agree that making them disappear as soon as you enter them is bad UI design, but the fact that I have to click on this button to move everything is also bad. I wonder if there couldn’t be a clean up every time you switch contexts or projects or if you stop using the application for several minutes if the clean up could happen automatically.
• The views are still a little confusing. This could be because I have never been a big subscriber to the GTD methodologies, I just want an application that organizes all my tasks, I don’t care about the FORMAL practice elements.
• The autoupdate feature continues to crash every time I install an update. Well, it claims to have crashed, if I look at the version of OmniFocus, it will say that is running the newest version.
• The App doesn’t feel like a finished Leopard App. There is zebra striping in some of the windows. I’m not a big fan of high contrast zebra striping, I feel like it takes away from the users focus.

Despite my misgivings, the app has a strong community and a good development core. There are a couple of really great things about the app that make me wonder how it will progress in the future. Here are a couple of the features that I like about OmniFocus

• Integration with iCal To Dos. This means that it will appear on your iPhone (or other syncable phone) currently. Also the way in which they do this is very smart. They allow you to select certain contexts to be synced with your iCal, which means if you are only interested in your Errands while you are mobile, you can set it to only sync those tasks and leave the rest off.
• Potential integration with OmniPlan. This is a great app for project management. It is the most Mac-like project management app I’ve seen and if you could hook OmniFocus to a specific project it would be easy for people to see what they have to complete, without having to look at OmniPlan and then copy it tasks to OmniFocus (this is not very DRY).
• Better integration that KGTD. This applications is specifically designed to do many of the things that KGTD did, but it does it natively, whereas KGTD was a bunch of add on Applescripts. KGTD also made all of your toolbars in OmniOutliner look like a KGTD app (they might have fixed this in later versions of OmniOutliner, but I can’t remember and don’t feel like installing this all over again).

This leads me to my next app, Things. This app is made by a much smaller company in Germany, so it might not have the same market penetration as the OmniGroup, but in my opinion this is what I really expect in terms of a GTD application. Keep in mind that I have only been using Things for about a day and I have been following OmniFocus for quite some time now, so my feedback on this app might not be as complete. Before I jump into feature analysis, here is a screenshot of things:

Now, Things is still in a beta stage, and the author claims that they will be releasing the code later in the spring. The price of this app will be $49 when released, compared to the OmniFocus $79. The overall look and feel of the app, though is still significantly more “finished” than OmniFocus, but some of the main features of OmniFocus are missing.

Here’s a rundown of what I like about Things:

• Very professional looking application. Okay, yes I'll admit it, looks are only skin deep, but when it comes to working with an app, if it is pretty look at, you will look at it more, therefore I feel that aesthetics can count for something here.
• The cost is lower than OmniFocus. Saving money is always a good thing.
• The layout is more structured than OmniFocus. By this, I mean that the menu on the let has specific sections: Collect, Focus, Organize; and then brakes down the tasks within this section. If I don't know the full GTD rules or I don't want to reread David Allen before I start using the application, this makes it more clear where I should put all my tasks.
• It allows you tag your items. This is both a positive and a negative for me. It allows me to put tags with an item that I think belong in different projects and then find them together, but the downside is, Tags replace the notion of context in OmniFocus. I think these are two different items, tags relate to the type of app, but I feel like context relates to where/how the task should be completed. By handling both of these with items with tags its not always clear how to differentiate which tags belong to which.
• The Focus section allows you to clearly see what you have to do and what you can do. The whole goal of GTD is to make it easy to see what you should be doing next. This focus section does exactly that.

Despite all these good features (and the one issue with tags that I have already mentioned), there are several other issues that I have with the application:

• No direct support for integration with iCal or mobile devices. This feature is on the roadmap, but it is unclear when it will be implemented, and I think it is very important to have it.
• No ties to any specific project management suite. This could cause issues with having to enter your information twice.
• Currently no way to recur items. If you want to repeat an item every day, right now, that just isn’t possible. This whole notion of recurring calendar events is probably pretty tricky to get right, but it is still an important feature that is missing. Again, this is in the future features, but no indication is provided on when it will be available.

There are a bunch of additional features intended for Things, which you can see here.

As for me, I have made up my decision, I’m going to try to stick with things for a little while and see how that works out. If OmniFocus has some major changes perhaps I will give it another look, but right now, I’m just enthused by the application. Also, if anyone else has any other task management applications they are using, please add a comment or contact me.

Peter is a senior in college pursuing a degree in Systems Engineering and Finance. Both of these factors came in to play when I started looking at the books I would recommend. Peter is very smart, but is not overly interested in programming. Not a passion, but maybe a necessity of the work world in which Peter is about to enter. The list below is designed to give Peter the necessary skills to be more effective on the job without forcing all the craziness of computer programming. This is NOT a list of the books I would recommend for a computer engineer or programmer. Peter knows some Java, but that is about it for actual programming.

To get it out of the way this is the list, in order, of topics I think Peter should cover, I will explain my reasoning below:

1. HTML and CSS
2. Python
3. Object Oriented Design (Design Patters)
4. Javascript/AJAX

HTML and CSS

I like HTML and CSS as a first choice for several reasons:

• Its simple and easy to use– Its a markup language not a full out programming language. That being said, there are still aspects of programming that can be applied to HTML and CSS.
• The Web is Everywhere– As the web matures it reach expands. More and more people are using the web every year. Even if you are not writing a product that directly uses the web, there is a good chance that your company will have a web presence. Also, most help documentation is written in HTML, yet another place that HTML and CSS can be useful
• Tools for development exist on almost every computer– All you need to learn HTML and CSS is a web browser and a text editor (and some disk space). You can find these tools on any computer for free. If you want to get serious about web design, you can end up buying better tools, but the basic tools are free.
• You See Results Fast– I feel a big problem with computer science education is the concern with getting everything “right”. This often prevents people from writing a lot of code. I know I have gone through this problem. HTML allows you to write code and get it out there quickly. Also, most browsers are VERY forgiving and will even display the right thing if you put in the wrong code. This is both a positive in a negative in terms of learning, but at least you will see results.

Given these reasons I chose HTML and CSS as the first topic. I could recommend a ton of books for this topic, but in order to keep Peter from giving up on this topic, I would recommend starting with one, getting through the rest of the topics listed above and then going back and looking at some other HTML books if that is a topic that really catches his interest. So here is my list:

1. Head First HTML with CSS– I have actually never read this book, but I have looked at several other books in the series. I think that the publisher does a good job of putting together a book that will teach topics easily and rapidly. Also the reviews are very positive.
2. Designing With Web Standards– This is a good second read. This book covers the basics of HTML and CSS and mostly explains why you would want to use them to build a website. I read the first revision of this book, and it was GREAT.
3. Bulletproof Web Design– this book is a collection tricks for designing websites. It is a quick read, and a reliable resource. This is not a complete reference, but it get you thinking correctly about designing sites.

Python

Python is a really great language. One of the language’s design goals was to create a easily readable, and therefore maintainable programming language, that was easy to learn. Despite the easy of use of Python it is still a very powerful and flexible language to learn. To elaborate here are the reasons I recommend Python for Peter:

• Clean Syntax– while there are some oddities in Python for the most part the syntax is incredibly clean. When looking at the code, you can most normally see what it is doing. This makes it great for a beginner language.
• Dynamic Data Typing– In some languages you have to be very careful to fully declare your variables with the correct types. Python uses on the fly declarations, and uses coercion to try and change variables to the correct type when being used in an expression. What does this mean? Less confusion of the programmer or reader of code.
• High Availability– Python is approaching version 3.0. It is available for many operating systems. It is also freely distributed source so you can probably compile it for many environments even if it is not natively supported.
• Good Documentation– There are online resources for learning the language. One of the books that I recommend below is available for free online. There is also a strong developer community.
• Its Extensible– You can use Python to do almost anything. It has libraries and extension for databases, web programming, robotics and more. Once you learn the language, you can apply it in many different areas. This could make it great for quick prototyping, which might be closest to what Peter would be doing with his programming.
• MIT is using it– Okay, so this is a lame excuse, but MIT has switched their intro CS course from Scheme(Lisp language) to python. While it is not good practice to take the lemming effect and just jump off the cliff because everyone else is, the professors at MIT know what their doing, so following them isn’t as bad as jumping blindly off a cliff.

I’m sure I’ve left out some really good reasons, but I believe I’ve covered the basics. Here is my list of reading for Python. Again, I would pick either of the first two to start with and then move on the next section. If you really want to get a firmer grip you can come back and read more later.

1. Dive Into Python– This is a great book that shows you how to program Python by example. It is quick to get you up and running and if you already know one programming language, its a GREAT place to start. Also, big kicker, its available for free at the Dive Into Python Website.
2. Core Python Programming– This is another great python book that was recommended to me by a friend. It is actually a very thick reference, but I made it pretty deep into the book starting from the first page.

Object Oriented Design Patterns

Regardless of whether it is the right path to take (which I believe it is), object oriented programming is dominating the world. Inheritance can reduce the amount of code written, which in turn can boost maintainability of larger projects. Not all languages allow you to use objects directly. C, for example, does not directly support objects, but the design principles learned from Object Oriented Design(OOD) can still be applied to C programs. If you need more convincing on OOD or information about it, I suggest reading the Wikipedia Article on OOD.

As for learning OOD, I can really not put my finger on a singular book that i have read that has taught me a significant amount about OOD, most of what I have learned I have picked up from reading and writing code. Still there is one canonical book and one book that I’m looking forward to reading as soon as I get a chance, and I’ve listed them below.

1. Head First Design Patterns– I have not read this book, but it looks promising and am hoping to pick it when I find the time to read it. It looks like it will give a good introduction to design patterns, and if it is like their other books in the series, it should be very readable.
2. Design Patterns– this is the canonical book on design patterns. I would recommend it as a reference. Many programmers will use the terms defined in this book, and if you have it as reference to look up their concerns it is worth. That being said, I don’t think that it is a good straight read, and would recommend the Head First book as a better starting place if you haven’t heard of design patterns before.

Javascript/AJAX

Now that Peter has knowledge of HTML and CSS, some basic programming and design, I’m pushing him towards Javascript and AJAX. Everyone is becoming aware of the concept of “Web 2.0”, and javascript and AJAX are at the heart of the new web. Javascript, however, is not your run of the mill programming language. There are some quirks to it, but AJAX itself is not overly complicated. I’d recommend learning Javascript after python because Javascript uses Prototypical inheritance. This is different than most programming languages, and can be rather confusing. Also, Python is more extensible. Javascript only traditionally runs within a web browser, there are a few other implementations like Rhino, but for the most part it only works with a web browser.

There are a ton of online resources for javascript. I don’t know all of them yet as I am still in the process of learning this language, but here are a few books that I have started on the subject:

• Head Rush AJAX– Great introduction to Javascript. It is a fast read and covers all the basics of AJAX and even goes into some basic DOM scripting as well.
• Javascript– is the definitive source on the Javascript language. Its a very tough read, but it does have a ton of interesting tidbits about the nuances in the language.
• AJAX in Action– I have yet to read this book, though it is sitting on my bookcase. I have a close friend though who highly recommends it, so I’ll include it here.

Recap

This list is far from complete. Computer technology is constantly changing. Anyone serious about the field needs to apply constant effort to read and keep up to date on important technologies. This list is a good starting place. Please post any additional suggestions to the comments.

This problem isn’t overly complicated, but C can be a tricky language. I used the language for a year of solid development, and never had to use anything this complicated.

My attempt at this problem without any resource ended up looking like:
double function_array(int foo)[];

Okay, before you laugh, remember I haven’t had to ever actually defined a complicated structure like this. What this translates to in C is: a function named “function_array” is takes an int “foo” and returns an array of doubles. This is not possible in C as you can’t return arrays. You can return pointers, which can be indexed as an array, but you cannot return an array.

The solution is actually:double (*function_array[])(int foo);which solves the problem as stated.

The resource that I used to find the answer is a book called Expert C Programming: Deep C Secrets. This book is AMAZING and you should definitely invest in it if you do any serious work with C. It does have a bit of a Sun systems bias, as the author was a compiler writer for Sun Microsystems, but the book has useful information for anyone using the language. There is a whole chapter on unscrambling declarations in C.

So there it is, another friendly reminder about declarations in C.

Update:

After rereading the post I realized that I was not content with my understanding of how to use arrays of functions. I came up with a mock project to work on. Lets say you have an input string, and would like to process it to remove some special characters (in my case I used “:”, ” “, and “t”). I wrote a function for each special character and iterated through all the functions on each string. This might not be the most expedient way of solving this problem, but it allowed to me to test the use of arrays of functions.

You can see the source: here. It has some brief inline documentation, but I’m not doing anything else too crazy. One additional note, I rediscovered that if you initialize a string like char *foo = "some string"; it stores it read only memory. Note that is different than char foo[] = "some string" which is stored in read/write memory.

In the post Jeff Atwood discusses hash tables and states the following:

Key-value pairs are quite common in real world data, and hashtables are both reasonably efficient in storage and quite fast at lookups, offering O(1) performance in most cases. That’s why hashtables are the go-to data structure for many programmers. It may not be the optimal choice, but unlike so many things in computer science, it’s rarely a bad choice.

and while I don’t disagree with this comment, I’m afraid that some programmers might misunderstand what is being said here. This post mostly covers the concept of hashing functions. This page is NOT saying that hash tables ARE the solution to EVERY problem.

One of the biggest problems I see in code that I look at is that people are not fully thinking out their data structures before writing code. Linked lists are great if you are going to be adding elements constantly and searching through your items rarely, but if search is of high demand, that maybe you would want to consider something that has less of a search time. I’m not going to go into Big O Notation here, but that is another worthwhile concept for any computer programmer to understand.

Hash tables are great for searching one-to-one mapped pairs. If you are keeping track of person to phone number, than a hash table would be an accurate representation, and a good tool to solve the problem. If the problem were to get more complicated, lets say we start holding the phone number in an object designed to store more than just phone information. If we are writing an App that only looks up by person, then hash table might still be the best choice. If we change our search parameters, perhaps we start looking for people in a certain town, or we have a phone number and want to see if it is associated with anyone in our records, this becomes a costly search.

We end up having to look through all records, because the hash is keyed off of data that is irrelevant to our search. This problem can be solved in many different ways, and the solutions are beyond the scope of this article. My one point is that while hashing is very unique and powerful, it is the the universal tool that solves any and all problems. A very important precursor to Jeff’s article is to decide whether a hash table is indeed the solution you seek, otherwise, space and hashing functions may be the least of your problems.