Big Nerd Ranch Blog

I attended "The Big Nerd Ranch: (https://www.bignerdranch.com/) back in like 2001. It was in a remote resort in Georgia. They only had 3-4 employees, IIRC. It was a heads down week, focused, touch. Aaron was amazing and often stayed until 11pm - Midnight because we all were still up implementing what we were learning into personal projects. I remember that class had folks from all walks of life. A guy who owned an auto-body place, an M.D, a stock broker, Los Alamos Labs, IIRC. My memory is a bit fuzzy here but there were only 8 of us.

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.

I feel like Big Nerd Ranch[0] did well. They had more of a seminar model, although they called their classes "bootcamps." Unfortunately, they couldn't make enough at it, and have had to pivot away from it. There was a post, hereabouts, recently, that spoke to that. [0] https://bignerdranch.com

That’s true in a lot of cases mainly because of the approach to rendering. So many languages focus on rendering the entire HTML structure before sending the first byte back, specifically so that the page can be wrapped in a cache. This forces a lot of memory allocation to build up strings and parts of strings that takes time on its own, is often repetitive over the same HTML tags and then all of that has to be garbage collected at the end of the request. The approach taken by Elixir’s Phoenix framework is so fast because it avoids all of those pitfalls. Most people have to do a double take when they see the speed comparisons. Here’s a great write up: https://www.bignerdranch.com/blog/elixir-and-io-lists-part-2-io-lists-…

Big Nerd Ranch | Android Developer | Atlanta,GA | Onsite | Remote Big Nerd Ranch specializes in developing business-building mobile and web apps for our clients. We also teach students what we've learned through our signature immersive bootcamps, and every year we release new books in our best-selling series of Big Nerd Ranch Guides. We are looking for full-time Android engineers to join the team in Atlanta. Learn more about us! https://www.bignerdranch.com/about/careers/

http://www.erlangpatterns.org/iolist.html This is also a very good introduction to how iolists work in Erlang: http://jlouisramblings.blogspot.com/2009/01/common-erlang-misconceptio… Starts with: --- There is a common saying that Erlangs I/O layer is slow. Bullshit. --- I recommend all of Jespers' blog entries. The newer ones are here: https://medium.com/@jlouis666 This is another article focused on Elixir, but same idea applies: https://www.bignerdranch.com/blog/elixir-and-io-lists-part-1-building-…

Big Nerd's Ranch (https://www.bignerdranch.com/) especialy for mobile app development. Their bootcamp is called "retreat", and they also work as developers and publish books.

I would recommend learning Objective-C. For your first app, you'll probably be doing a lot of Google and Stack-overflow searches and the vast majority of results and examples are in Objective-C. I would also recommend picking up one of the Big Nerd Ranch iOS books [1] as I found them quite helpful. Good luck. [1] http://www.bignerdranch.com/we-write/ios-programming.html

The last course (winter 2013) is IMHO a bit too lightweight, it avoids going deeper into some stuff that was touched in earlier courses. I dont's use storyboards so that's another minus for me, because everything is storyboards based. In any case this is solid course and highly recommended. As for books the two I'd highly recommend would be the already mentioned "IOS Programming: The Big Nerd Ranch Guide"[1] and "Programming iOS 5" [2]. Ray's tutorials are also worth checking out. [1] http://www.bignerdranch.com/book/ios_programming_the_big_nerd_ranch_gu… [2] http://shop.oreilly.com/product/0636920023562.do

The bible is certainly Aaron Hillegass' Cocoa Programming for Mac OS X - http://www.bignerdranch.com/book/cocoa®_programming_for_mac®_os_x_3rd_… The Apple documentation is outstanding. http://developer.apple.com/resources/ Check out ObjC and iOS podcasts. My favorite Cocoa website it http://theocacao.com/ Delicious might also help you: http://delicious.com/tag/cocoa

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-… 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…

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/

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_gu… 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.

I would suggest Cocoa Programming for Mac OS X, even though it's based on Objective-C and the book is old. That means it's based upon older versions of Xcode and Mac OS (like ~10 years old). Conceptually it's a good book, but because of it's age the code examples, etc are outdated. The publisher does have forums which can be helpful: https://forums.bignerdranch.com/c/cocoa-programming-for-os-x-5th-editi… They also have a Swift book, but I haven't personally read it. They also have an Advanced Mac OS X book, but it's also old and isn't on their website anymore. https://bignerdranch.com/books/

I think that’s already possible using git smudge. Example here: https://bignerdranch.com/blog/git-smudge-and-clean-filters-making-chan…

Big Nerd Ranch books on iOS and Android focus on projects. https://www.bignerdranch.com/books/

Macros are not really necessary and you don’t have to know the inner workings of everything for doing well with strings in Elixir. The secret for working with strings in functional languages (or in languages with immutable strings) is to realize most operations, such as concatenation, end up copying the strings. So instead of saying “string1 concat string2 concat ...”, it is better to collect a list of strings and build one final string only at the end. Here is an Elixir specific article that goes more in-depth into this: https://www.bignerdranch.com/blog/elixir-and-io-lists-part-1-building-… Other languages may provide specific data-structures for this purpose, such as ropes, but in a nutshell that’s all there is to it.

Compiled views https://www.bignerdranch.com/blog/elixir-and-io-lists-part-2-io-lists-…

For one, they leveraged the speed of iolists on the BEAM very well. https://www.bignerdranch.com/blog/elixir-and-io-lists-part-1-building-…

Yes, immutability, pattern matching, type inference, etc are not new ideas. Pattern matching is another concept that’s making its way into popular programming. https://www.bignerdranch.com/blog/pro-pattern-matching-in-swift/ https://stackoverflow.com/questions/2502354/what-is-pattern-matching-i… C# and Java are also adding this feature. We’re taking the long way to becoming Haskell and oCaml programmers.

Big Nerd Ranch for iOS app development. https://www.bignerdranch.com/books/ios-programming/?gclid

Clang (since LLVM version 4.4) has flag -Weverything which really reports everything https://www.bignerdranch.com/blog/a-bit-on-warnings/

I assumed they were talking about UIDynamics (https://www.bignerdranch.com/blog/uidynamics-in-swift/)

Big Nerd Ranch books - at least the Android one https://www.bignerdranch.com/books/

Are you thinking of IO lists[0] when you talk about templates with respect to web frameworks? [0] https://www.bignerdranch.com/blog/elixir-and-io-lists-part-2-io-lists-…

Phoenix uses IO lists for very efficient templating. Read more here https://www.bignerdranch.com/blog/elixir-and-io-lists-part-1-building-… and in part 2.

I've only recently tried out DTrace on OS X, and I'll admit to being kinda floored at what it can do. To think I used to be satisfied with strace on Linux! Seeing the tracing capabilites of Linux expand is exciting indeed. Edit: the couple of tutorials that finally unlocked DTrace (on OS X) for me are: https://www.objc.io/issues/19-debugging/dtrace/ https://www.bignerdranch.com/blog/hooked-on-dtrace-part-1/

> Note that this is from 2015 That's true. The submission is only the first part of a series that spans several months. I pasted the links below for convenience[1]. The last part (so far) is from April 14, 2016. > he recent push to improve Rust's cross-compilation story may have made the info within obsolete. Now that we have rustup [2], what is described in the first part should be much easier. I find it still worthwhile because it helps to understand what rustup does for you automatically. Researching this topic is actually how I found the article. [1] https://www.bignerdranch.com/blog/building-an-ios-app-in-rust-part-1/ https://www.bignerdranch.com/blog/building-an-ios-app-in-rust-part-2/ https://www.bignerdranch.com/blog/building-an-ios-app-in-rust-part-3/ https://www.bignerdranch.com/blog/building-an-ios-app-in-rust-part-4/ [2] https://www.rustup.rs/