You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License.

1. The pointer used to point to memory that was ok, but its chunk was deallocated.
2. The pointer is corrupt.

1. Run Build and Analyze. Make sure you fix or understand every single error it flags. I personally have 0 Build and Analyze errors in every project I have and I go out of my way to keep it that way. If I ever get a false positive, I figure out how to make Build and Analyze understand what is going on, so that it doesn’t flag it.
2. Run scan-build with all checks on. This isn’t built in, so if you’re in a hurry, skip this for now. scan-build is the project that Build and Analyze is based on. It can be run with much more thorough settings.
3. Set up Xcode so that it never deallocates. Instead, it turns objects into Zombies that complain if they are used. See Tip #1 on this post for instructions.

1. The pointer could have never been initialized.
2. The pointer could have been accidentally written over because you overstepped the bounds of an array
3. The pointer could be part of an object that was casted incorrectly, and then written to
4. Any of the above could have corrupted a different pointer that now points at or near this pointer, and using that one corrupts this one (and so on)

1. Enable Guard Malloc (Tip #2) - this makes the datastructure that represents the allocations much more sensitive to corruption. You need to use the enhanced features of the debugger to get anything out of it (explained in the tip).
2. The line of code that triggers the crash is a clue to what pointer is corrupt. If you move it around it might be able to help you narrow down the point of corruption.
3. If all else fails and you are desperate, try Valgrind.

1. Corrupting a pointer doesn’t immediately trigger EXC_BAD_ACCESS. Neither does using a corrupted pointer unless it’s specifically now pointing to memory that isn’t mapped to your application.
2. Deallocating an object doesn’t immediately release the memory to the operating system -- only when the chunk is unused, can it be returned.
3. The line of code that is triggering the EXC_BAD_ACCESS might not be the problem. It can be a good clue, but don’t assume the problem is this code.

1. Run Build and Analyze: This kind of Build is very good at finding retain/release bugs. Take a good look at everything it flags.
2. Even better, run scan-build. I did a test recently, and found that some common errors are off by default in Build and Analyze that can be turned on in scan-build.
3. Choose Run > Enable Guard Malloc in the menu, and then re-run your application. This finds a whole class of buffer overrun issues. If this detects it, you’ll see a better error in the console. Read this to see how to use Guard Malloc once it’s enabled.
4. You can instruct the compiler to ignore release calls and then report if anyone is sending messages to objects that would have been deallocated. This results in much better errors in the Console if it detects them.
5. Valgrind is the gold standard for finding memory bugs on Linux, and here’s a way to get it working in the iPhone Simulator.

1. Download scan-build
2. Just unpack it into any directory and add that directory to your PATH
3. Open a Terminal and cd to your project’s root directory
4. Run scan-build and view results

I've had an idea for an introductory book on programming that follows the model of "trainer" books for learning a musical instrument. Most of these books are organized like this:

1. There’s a bunch of exercises.
2. Each exercise is 1 or 2 pages.
3. There’s only a little bit of prose.
4. You do each exercise exactly, then move on.

[It will] provide UI components, JSON and XML parsers, HTTP and HTTPS networking, secure storage, and other features. Other APIs like audio and dictionary access will be available in a future release of the KDK.

The darndest thing happened in the last five days and I was fortunate to be privy to it. Apple has gotten people excited about computing. But this time, it’s not nerds or geeks and certainly not IT industry analysts. It’s everyone else. I had a curious set of three conversations this week. One with a grandma, one with a technophobe and the third with a self-proclaimed luddite.

The reason I’m starting to think the Old World is ultimately doomed is because we are bracketed on both sides by the New World, and those people being born today, post-iPhone and post-iPad, will never know (and probably not care) about how things used to work. Just as nobody today cares about floppies, and nobody has to care about manual transmissions if they don’t want to.

In his 1980 classic Competitive Strategy: Techniques for Analysing Industries and Competitors, Porter simplifies the scheme by reducing it down to the three best strategies. They are cost leadership, differentiation, and market segmentation (or focus). Market segmentation is narrow in scope while both cost leadership and differentiation are relatively broad in market scope.

1. Because of the free 3G, Amazon needs to have a class of apps that are subscription based. This may seem like a downside, but if you can keep the monthly cost low, this gives an Amazon app something that has been missing from the Apple AppStore: Recurring Revenue
2. Amazon is a clear leader and innovator in e-commerce -- specifically cross-selling. I think it’s very likely that Amazon will be able to surface apps all over their store. Make an app that helps people choose a digital camera, and it may be promoted on every camera page.
3. The Kindle will be one-third to one-half the price of the Apple device, which makes it very attractive to do a large rollout to a mobile workforce. Insurance adjusters, delivery truck drivers, on-site construction, etc. need to read documents -- they don’t need an iPod, fart apps, or games.
4. The Kindle will probably always be smaller, lighter, and use less power -- Apple could surprise me here, but the Kindle is so low-powered, it’s unlikely that they can’t keep up.
5. Hardware keyboard -- Apple could clearly innovate here -- I’m guessing with an external bluetooth keyboard. If so, that adds bulk, weight and sucks battery.
6. The e-ink display -- no color is a downside, but the e-ink can be read outside -- again, think outdoor, mobile workforce.
7. Amazon’s Kindle DRM and book deleting are cause for concern, but if they have any sense, they will learn from Apple’s experience with AppStore rejections and loosen up. It doesn’t appear that they will from my first looks at the KDK.

1. The Kindle runs Linux
2. Kindle GUI’s are written in Java
3. There will be three models of apps, free, one-time purchase, and subscription. The first two will have a monthly bandwidth cap of 100KB/user.
4. Advertising is listed as something you can’t do -- perhaps they mean an app that only advertises, but even so, why not? Mobile advertising is large part of the app ecosystem, so I assume in-app advertising will be allowed.
5. A generic reader is not allowed -- again, does this mean a PDF reader wouldn’t be allowed? I can see Amazon not wanting the 3G being used to buy from other stores, but why not let me read content I get from other means (or from subscription apps).

The GHPCC planned for Holyoke will not only provide an invaluable increase in the computing capacity that would bring all these benefits to the partnering institutions. It would also serve as a showcase of green energy use and green facilities design, be scalable to meet the needs of additional partners and computational demands, and serve as a catalyst for economic, educational, and workforce development in Holyoke and the region.MIT had developed plans in 2007 to locate a high performance computing center in Holyoke due to the region’s quality access to the internet, affordable land, and availability of low-cost and renewable energy. The impact of the global economic recession led MIT to suspend their plans and subsequently reach out to leaders at the University of Massachusetts to jointly address capacity needs for high performance computing.

Yay! It took several months but as of today I was able to search for my app and I saw it listed inside the app store. Now you may be saying "so what", but if you have ever looked into the steps that this takes, you know it's something to celebrate.My app is a very simple game, but I think I've learned enough during this process to distill some important lessons that may help you if this is something you've been wanting to do...

• Lose Weight
• Get Your Finances in Order
• Go Greener
• Curb Your Vices
• Get in Shape
• Relax More
• Pursue a New Career
• Upgrade Your Technology
• Organize and Optimize
• Start a New Hobby

Habits by Louis Franco helps users form good habits, which sounds simple enough. But developing habits requires a bit of time and discipline. It requires repetition and awareness. Habits keeps your calendar free from clutter associated with routine tasks or the general stuff of life.

Changes have been relatively slow to come to the App Store. However, with the addition of review copies, as well as limiting ratings to those who've purchased applications, Apple has made changes that have been welcomed by developers. I'm hopeful that the App Store will continue to improve over time and address additional issues.

Having more than doubled over the last two months, Gaming remains the largest category accounting for a quarter of all apps. The fastest growing categories were Education and Lifestyle. Medical is the newest app category and as of the end of November there were over 80 medical apps, the 10 most popular of which were free. Among Game apps, Racing, Music, and Sports were the fastest growing Game sub categories.

Have the iPhone use the gps data... upload where I was a minute ago and where I am now. Figure out my speed and route. Use the data to tell other RadaR users which route is best. It's worth $20 a month if you live in a place with traffic jams. It's a natural monopoly--once someone figures it out, why wouldn't everyone want to use the market leader?

Here's an easier one that you could probably sell as well. I type in a phone number and enter a time. Record a message and press go. I can cue up a bunch of messages that are based on time. I can have groups get the message I record, at the time I want them to get it.

The fix for pricing too low is really simple: raise your prices. Most $0.99 apps should become $9.99, $4.99 apps should become $14.99, and so on. With a $9.99 app, you’d make $7 per copy and at 16 copies per day, you’d make about $40,000/year. That’s not a great income, but that could potentially support one iPhone product being developed in some Iowan’s wheat field.

iPhone apps are typically much smaller and more focused than desktop apps and as such, should be priced accordingly. In addition, you need to take into account the much larger market that you’re dealing with here… Apple is selling well over 10,000 iPhones per day and these are all potential new customers, plus all the existing iPhone owners and iPod touch sales.

Generally, I use Habits to help with Sharpen the Saw type of tasks -- things I want to make sure I do every once in a while, but not necessarily at a specific time. Also, unlike a recurring event in a calendar, I can record how well I do with them (if I do them late, early, or skip them).

[...] crash as early as possible. It's no fun to figure out a crash bug once the culprit function has already returned. You really want the root cause somewhere on the call stack when it's detected.

1. Declare all of your object pointer @properties as retain unless you have a really good reason not to. Then the setter that is generated will automatically call retain when you assign. When you reassign, it knows to call release on the old value.
2. In your dealloc, assign all of your @properties to nil. This has the effect of calling release on the current values if they are not already nil.
3. alloc returns an object with a reference count of 1 -- so you have to balance with a release.
4. If you alloc, then you should try to release in that same function. To retain the value, assign it to something that retains. Exceptions are if you are a factory function that is returning a value up to be retained by the caller.
5. Obviously, each retain call needs a release.
6. Built-in convenience functions return objects that are autoreleased. That means you shouldn't call release on them -- the framework will call release at some point (they are registered in an autorelease pool that that is serviced when you return back to the framework). If you created the object without an alloc/init pair, you don't need to call release unless the docs say you do (but they probably don't)
7. Check all of your work with the leak detector. Also, if you crash, you're probably doing it wrong -- I will have more to say on that soon.

1. Go enroll in the iPhone developer program before you start. Yeah, I know -- it's 99 bucks. But if you have an idea and a reasonable chance of doing it, just take the plunge. I joined after I finished, and that caused a lot of delays -- I could have been completing the other necessary steps in parallel.
2. As soon as you're in, go get your application contracts going. If you want to make paid applications, you have to give Apple your tax and bank information. Again, it takes some time to get approved, so start early.
3. If you don't know Objective-C -- don't worry, that's the easy part. The primer on the iPhone developer site should be good enough if you know C/C++.
4. For Cocoa Touch, I recommend Erica Sadun's iPhone Developer's Cookbook. The chapter on coverflow is worth the price of the book, but everything else is there too (navigation, touch, location, contacts, etc)
5. I also highly recommend iCodeBlog. Once you have some basic knowledge of the framework, check out the to-do application tutorial.

• Adam Scarborough
• Chas Emerick
• Paul Bissex
• Rick Minerich

The expression generated by the macro will be evaluated in place of the original macro call. A macro call is a list whose first element is the name of the macro. What happens when we type the macro call into the toplevel? Lisp notices that [it] is the name of a macro, and

1. builds the expression specified by the definition, then
2. evaluates that expression in place of the original macro call

I use the property that no number in the interval [n .. 2*n-1] is divisible by n (except n itself) so it's safe to process the whole interval with the current set of known primes. Hence this interval can be divided into m intervals (where m is the number of cores) for parallel processing.

I'm sorry to say I can't think of a less promising candidate for parallelization :( The 3 things you would want in something to parallelize are independent data/work, moderate-to-course-grained work units and/or complex coordination logic that would be simplified with threads. (Note - wanting it to run faster is not enough :) Here you have none of those - the data/work is interdependent (more later), the work is very fine grained (seq walk and a remainder test), and the logic was pretty elegant.

I re-read Okasaki's paper yesterday and woke up today with an idea for speeding up the Clojure vector conj and pop. They are now 2-5x fasterthan they were. The trick is to keep the tail of the vector out of the tree until it is a full (32-element) node. Note that this greatlyspeeds up vector construction, which typically consists of repeatedly conj'ing onto [].

An interesting point of comparison with purely-functional solutions such as that which Okasaki writes about is that the Clojure vector can be log₃₂N specifically because I can use mutation - when cloning, i.e. the tree is log₃₂N deep and a node can be copied in O(1) time due to arraycopy + indexed array set. And yes, the vectors are optimized for lookup - in practice, log₃₂N blows logN out of the water.

1. If the key and value match the LeafNode, then it is just returned -- nothing is created since you haven't changed anything.
2. If just the key is the same as this node, a new LeafNode is created with the same key and the new value and returned (remember, this is a persistent data-structure, so we do not change the LeafNode, we create new nodes to build up a new hash-map).
3. If the hash is the same, but the key is different, then a new HashCollisionNode is created that holds onto this LeafNode and a new one that has the same key and the new value. HashCollisionNodes simply hold onto an array of LeafNodes whose keys have the same hash.
4. If the new key doesn't have the same hash (the common case), then a BitmapIndexedNode will be created. At first it contains just the old LeafNode in its array of nodes, and then assoc() is called on it with the new key and value.

1. If the node is an EmptyNode, it returns null.
2. If the node is a LeafNode, it returns itself if the key matches, otherwise null.
3. If the node is a HashCollisionNode, it calls find() on each LeafNode it holds, if any return themselves, then that is returned, otherwise null.
4. If the node is a BitmapIndexedNode, it first checks to see if it has a node where the five bits being used matches and then calls find() on it, if it doesn't, it returns null.
5. If the node is a FullNode, it acts like a BitmapIndexedNode with all bits of the bitmap set, so it just calls find() on the node corresponding the five bits in the hash at its level.

1. Quote syntax, which uses '
2. first and rest which are car and cdr. Clojure also supports combinations like frest (cadr) and rrest (cddr)
3. In clojure, extra parens are usually not necessary -- look at how cond is implemented to use variable arguments rather than a single list argument (which would require extra parens)
4. My first usage of Java interop (using instance? to find out if an expression is atomic or a collection)

1. fn [arg1 arg2] is lambda (λ), so where fixed-point takes a function as the first argument, we create one on the fly to be (average (/ x y) y) where x is the argument to sqrt (closed around our function) and y is the argument defined by fn.
2. Since clojure compiles to Java and uses Java calling conventions, it does not have automatic tail-recursion. Instead, you use the recur special operator which will create a constant space loop back to the last loop or function definition. Loop/recur is explained on the Functional Programming page of the clojure site (at the bottom).

1. clojure uses defn to define functions and puts arguments in []
2. sum and average implementations show how clojure can overload on arity (number of arguments)
3. try is reserved for exception handling, so I renamed the try function to try-sqrt
4. the answer is in clojure's rational number format, since all of the computation was adding and averaging integers and rationals, the result is a rational number and clojure preserves that.

1. Useful algorithms
2. Shown in real-life situations
3. With real data that you can get yourself

Now we could use progressive disclosure to help reduce the complexity of that JButton class: put the expert stuff in an object returned by a getExpertKnobs() method, and the graphics subsystem hooks in an object returned by a getIntegrationHooks() method, and you would be left with a button API that had just a handful of methods—the basic methods we all need.

• Kathy Sierra, in her Creating Passionate Users blog, thinks that we shouldn't have slides. She also has this crash course on learning theory (with pictures and a workbook). 
• Seth Godin has a free-book called Really Bad PowerPoint. First tip: "No more than six words on a slide. EVER"
• Guy Kawasaki has the 10/20/30 rule of PowerPoint.
• The Beyond Bullets blog has great tips.
• The Zen master of presentations, Steve Jobs, vs. Bill Gates.

Suppose you’ve got an application where a markup language would be handy, and you’re wisely resisting the temptation to build your own. What are you going to do, then?

The smartest thing to do would be to find a way to use one of the perfectly good markup languages that have been designed and debugged and have validators and authoring software and parsers and generators and all that other good stuff. Here’s a radical idea: don’t even think of making your own language until you’re sure that you can’t do the job using one of the Big Five: XHTML, DocBook, ODF, UBL, and Atom.

Any program that accepts user input will need to separate good input from bad, and to make sure little of the latter gets recorded.

A person reaches through a program's interface to manipulate the domain model. Although the interface is itself a program (an interface model and graphical machinery), its purpose is to enable the direct manipulation of the domain model as transparently as possible. The user interface is programmed to create the illusion of control in the mind of the user. To this end it must provide sufficient clues of the model's state so that sensible operation is the norm.

Created to mimic the design in this NUnit presentation.

Most UML diagrams shown in books, such as mine, are sketches. Their emphasis is on selective communication rather than complete specification. Hence my sound-bite "comprehensiveness is the enemy of comprehensibility"

• Test code before refactoring or optimizing – The purpose of refactoring and optimizing is to make the code do the exact same thing but in a different way. It is perfectly suited to being unit tested since tests you write at the beginning of the change need to pass at the end.  And, the unit tests will let you make more aggressive changes.
• Test code while learning what it does – When you're trying to learn a body of code, a unit test is a good way to check your assumptions about how the code works. This strategy also works well in training a new developer—explain the code by writing new tests for it together.
• Before fixing a bug, write a failing test – This is the perfect time to add a test since reliably reproducing the bug is a good first step. The beauty of this is that now the bug won't return.

For casual users, learnability and simplicity are more important than usability and power. In that sentence, by “learnability,” I mean, the ability for novices to figure out how to get tasks done rapidly. By “usability,” I mean only the ability to do tasks in a convenient and ergonomic way without making mistakes and without needing to do repetitive tasks. A data entry system that minimizes keystrokes by prefilling things and automatically jumping from field to field is more usable for experienced users, but it's harder to learn because it behaves unexpectedly to a novice.

But I wonder if a language designed for programming is really the right language for writing tests. The point about tests is that they operate by example. They don't try to cover how to handle any value, instead they describe specific scenarios and responses. I wonder if this implies a different kind of programming language is required. Perhaps this is the truly startling innovation in FIT.

• News Group Software —  There are plenty of easy to install and use newsgroup applications. I've had good experiences with Snitz, which is free and full-featured.
• Advantages: Familiar interface, every edit is marked with author, support for alerting via e-mail is common
• Disadvantages: Knowledge is in discussion/serial format, hard to edit old entries, linking to other entries can be hard, requires ability to install software on the server, may not support attachments
• Wiki Software — A Wiki is a website where every page is editable by the reader. The best known public example is the WikiPedia, but the concept started at the Portland Pattern Repository. It's a powerful idea, but depending on the exact software you use, it can be hard for some people to use. Here's a list of wiki implementations.
• Advantages: Everything is editable, linking is easy, free implementations are available, pro versions track users and edits
• Disadvantages: Can be hard to use, requires ability to install software on the server, may not support attachments
• Content Management Software — CMS tools can be as expensive as KnowledgeBase tools, but for ease of use and quality of the resulting site, they cannot be beat. I use CityDesk for this site and others (Note: as of 2007, I use RapidWeaver). It averages about $100 a user for contributors and $300 for the site designer, but for small sites, a free version is available.
• Advantages: Complete control of resulting site, linking is easy, everything is editable, very easy to use, attachments usually supported
• Disadvantage: Must set up templates, edits not usually logged

Using Visual Basic and other programming languages on a test project are some of the real-world techniques we end up using when our high-priced automated testing tools just can't get to that important information. This is not meant as a criticism of the automated test tools on the market today [...] However, by default, these tools can't possibly keep up with every need on every test project. Most testing organizations find that at some point they need to resort to using programming-experienced personnel to write code to supplement their testing.

This article walks you through the process of setting up a basic service monitor and event handler for a common J2EE n-tier system. Developers of J2EE systems will be able to use JMX4ODP to create testing suites to help them develop more reliable systems. J2EE application administrators will be able to use JMX4ODP to simplify and regulate the management of deployed systems.

JUnit bills itself as a regression-testing suite for code objects, but it's not much of a leap to see it as a tool for distributed system diagnostics. JUnit runs tests by instantiating objects, invoking their methods with known inputs, and checking the output against expected returns.The article is very Java and J2EE focused, but the concepts are applicable to any service monitoring project.

• It enables Daily Builds.  You can't build on a clean machine from the source on your drive. You need there to be an official, working version of the source.
• It enables bug fixes to released versions. Using labeling and branching features, you can fix a bug in a released version to a user without also giving them every change you've made since then. This is important no matter how many developers you have.
• It enables binary search bug fixing. Outlined in this JoelOnSoftware article, it's simply a way of finding a bug by systematically trying each archived build until you find the one that introduced the bug.  Then you check the log entries to see what you did.