Big Nerd Ranch Blog

I wrote my answer to this a few years ago:

https://www.bignerdranch.com/blog/a-crash-course-in-awk/

A tl;dr for the following tl;dr: it's great for quick-and-dirty processing of logs.

The tl;dr is that AWK is simple language that lets you use a line-oriented event driven programming model to process text. This abstraction is simple enough to be readable and maintainable, but powerful enough to parse and process text with line-oriented structure.

The example linked elsewhere is worth studying, because it truly is one of the prettiest pieces of programming I've seen in a long while:

https://c2.com/doc/expense/

If you don't know anything about AWK, here's all you need to know to grok this:

1. An AWK program is a list of [event] { code } pairs. All pairs are run in sequence on each line of input; if the "event" evaluates to true or is a matching regex, the matching code runs.

2. { code } on its own runs unconditionally.

3. The input is automatically whitespace delimited into fields; $1 refers to field 1, $2 to field 2, etc

4. NF is a special value that yields the number of fields

5. Assigning to fields replaces the text in those fields.

6. ($1+0) != 0 implicitly converts $1 to an integer; if it fails, the value is 0.

There is a lot of implicit loose typing in the language, and usage of undefined variables is idiomatic. Functions aren't easy to use, either. So it's not well-suited for programming in the large, or even the medium. But for the scale of programming seen…

In practice, functional languages typically use persistent data structures, which represent collections such as dictionaries, vectors, sets internally as trees. Adding, removing and updating data requires changing a path in this tree while sharing the remaining of the structure. It is not a deep a copy and a really large map won't be very expensive to modify. Rich Hickey has a good talk on the matter: https://www.youtube.com/watch?v=dzP05hEDNvs

There are also optimizations that are straight-forward to understand and implement once you assume immutability. For example, take the following function in Elixir:

def some_list do
[1, 2, 3]
end

Because a list is immutable, when code is compiled we put such data structures that appear literally in the code into something called a literal pool. Anything in literal pool is loaded when the code is loaded. Now every time you call that function, we return the same list and we don't create new instances/copies on every call. That list may be embedded in a map, another list, whatever, and still point to the same memory representation because nothing will ever change it.

Here is an example that leverages this in the context of a web framework for great rendering performance https://www.bignerdranch.com/blog/elixir-and-io-lists-part-2-io-lists-in-phoenix/. While this is definitely achievable in other languages, we get it pretty much for free with immutable data structures and it is a natural mechanism to reason about. IanCal…

Sadly I am not aware of any specific resources on iOS performance tricks or optimizations. You might find something of use in Aaron Hillegass' beginner's book on iPhone development (on http://www.bignerdranch.com/) - his previous book on Cocoa has gotten a lot of praise, and there's a good chance that his iPhone dev book holds the same quality.

The things I commented about in the code examples were mainly general cases of bad programming; f.e., one of the applications did a frame rendering pass via a loop that ran 100k times per frame, and as the first thing in each run of the loop (instead of just once at the start of the application) it initialized a few variables that end up having the same value through the entire run of the application, resulting in the unnecessary addition of 200k function calls with consequential variable declarations per frame, totalling 6 or 12 million extra function calls PER SECOND, depending on if the application rendered in 30 fps or 60 fps. While it might not look like a big mistake, things like these are easily picked up by people who might consider it sane, healthy and clean programming from an "engineering" perspective, but even the smallest mistakes can be the best recipees for killing handheld battery life and producing lousy software.

That said, the Cocoa/iOS ecosystem has better resources for diving deep into its style and capabilities than any other I have worked with.

The Big Nerd Ranch set of books [1] is fantastic. It explains "how we do things" and "how we learn about new things" for its community better than any other book for any other community I've tried. It doesn't just teach a language or show a few examples, but actually walks you through the experience of reading documentation for, playing around with, and ultimately building a finished app using a new API or part of the ecosystem. After you're done with the books, there is plenty to learn, but you know where to look and how to go about doing it.

Then I compare that to what it took me to become a web programmer. While it seems "easy" now, the amount I had to read about http, OSes, browsers, the dom, security, performance, etc. is astonishing. Without any of these topics, I would have made terrible mistakes. And each of these topics was covered in a separate book, which often showed best practices for that topic mixed into code using poor practices with regard to the other topics.

[1] http://www.bignerdranch.com/we-write/

I am going through the exact same thing. Last weekend I decided iOS would be my project for May and started digging in.

There is a TON of information out there. Too much. Most of it is outdated, and while the Apple documentation is a great resource, it is just not structured in a way for beginners.

Enter the Big Nerd Ranch.

http://www.bignerdranch.com/book/ios_programming_the_big_nerd_ranch_guide_nd_edition_

I think I got the kindle version for $22. It is perfect. Just released a little over a month ago, it uses Xcode 4.3. The first few chapters have no iOS stuff as they bring you up to speed on Obj-C and from there you start building the bases of iOS.

I love that they make you strip out all the code from the iOS templates and make you do it yourself. It really is a structured learning experience rather than just an information dump.

I'm only about 1/3 the way through so far - but so far it's been exactly what I needed.

Director iOS & Mac Engineering | Big Nerd Ranch | Atlanta, GA | FULL-TIME | ONSITE
Big Nerd Ranch specializes in developing native mobile and web apps for our clients. We also teach students through our signature immersive bootcamps, and we release books in our best-selling series of Big Nerd Ranch Guides.
We’re looking for a Director of iOS and Mac Engineering to take our stellar team to the next level in quality, innovation, and organization. You should be as passionate as we are about leading, learning, and performing. You will work among the smartest, most genuine people you know. In this role, you will thoughtfully manage engineers, improve process and practice, and collaborate effectively with other teams like Design, Web, Training, and Sales. You will work from our Intergalactic Headquarters in Atlanta, Georgia.
View details and apply online: https://www.bignerdranch.com/about-us/careers/