AJAR DEVELOPMENT

Ran into an issue with the section titled adding-flair. Added a link from the score box and misnamed it, then thought i could just naively delete it from the GameViewController and everything would work. Threw a crazy error. Googled it and found this: which shows how you go back into the main.storyboard and delete the offending deleted connection. This GUI for the GUI stuff is a little tricky but seems like it'll be a lot faster once i get the hang of it.

s coming along nicely. Just finished the let-them-fall section- had a minor error with no blocks appearing because i forgot to add delegate?.gameDidBegin(self) to func beginGame() in the Swiftris.swift class. Fortunately i had a good enough grasp on the game to follow from the init function to the didTick function to the swiftris class and spot the missing line. Wish i knew it well enough to know off hand that that's what was missing, but i guess i do now so that's progress.

Is there a term for finding excuses so you don't have to work on something until someone else does something you know will take some time? We need a better vocabulary for procrastination. It's a central issue of our time- things you know you should be doing which you are not have infinite variance. Right now my major struggles are with complicating things more than i know i can make progress in (procrastinating via feature creep), generating pauses for other peoples' agency as a way of buying time, avoiding work with other work (procrastinating via delegation of tasks within your present capability to absent agents), refusing to prioritize due to issues with cardinality as a concept (procrastinating via refusal to address a central philosophical issue, and secondarily employing that issue outside of its relevant domain) I'll call these Featcrasting, Delcrasting, Philcrasting, and coin their cousins DesignCrasting (descrasting? procrastinating via design), Excucrasting (procrastinating via argument/excuses for why things can't be done),

Is there a term for finding excuses so you don't have to work on something until someone else does something you know will take some time? We need a better vocabulary for procrastination. It's a central issue of our time- things you know you should be doing which you are not have infinite variance. Right now my major struggles are with complicating things more than i know i can make progress in (procrastinating via feature creep), generating pauses for other peoples' agency as a way of buying time, avoiding work with other work (procrastinating via delegation of tasks within your present capability to absent agents), refusing to prioritize due to issues with cardinality as a concept (procrastinating via refusal to address a central philosophical issue, and secondarily employing that issue outside of its relevant domain) I'll call these Featcrasting, Delcrasting, Philcrasting, and coin their cousins DesignCrasting (descrasting? procrastinating via design), Excucrasting (procrastinating via argument/excuses for why things can't be done),

Username issue was due to a leftover test to see whether the PFUser class, properly instantiated, hooked up to Parse okay. Commented it out and everything's fine.

Was getting 'Apple Mach 0 Linker' errors all over my project once i fixed the ParseUI bit. Found the answer here: Moved on to a new error: username my name already taken.

I'm currently working on the BloQuery projects at the same time as I conscript my brothers into generating copy for making the Pong game unique enough to qualify for the App Store. I was just working through the Parse tutorial and ran into this issue: Basically, when you try to follow along with the video you run into an error where the PFLoginViewController class isn't integrated with the simple `need an additional ` ` command to get all of the UI elements.

Cloned Blocstagram to trim the list view template and use it for other projects. Made a new ListViewTemplate file for the trimmed just-list-view that I can use for the messenger and query projects. Still working on Swiftris but want to get ready for Steve meetings on Mon and Tues. Finished Pong a while back and been working on Swiftris for a couple of weeks now.

20150324 1619qtime 0820CST Bloc section 39- Blocstagram- Accessing the Image Library 1621 Start video 1- refactoring cropping and resizing/panning. We'll be using the ALAssetsLibrary to retrieve assets from the user's 'photos app.' Also be using UICollectionView, a tableView inspired class to display data with a more flexible layout. Also be doing some refactoring on prior code. Users are going to want to crop their image into a square. We'll move our 3x3 grid of white bordered squares into a new class. New subclass of UIView called CropBox. Nothing in the interface. .m will jack code right out of CameraViewController. Couple of differences- userInteractionEnabled is no, view doesn't handle any touch events. Also, y coordinate is replaced with 0, view controller will position the box appropriately. Now to import the crop box class, and clear out the old stuff. autocomplete…. so handy, yet so disconcerting at times. Cropping logic doesn't need to calc the grid's perimeter, only needs to use the crop box's frame. Now to handle panning and zooming to crop the perfect square image. We already handled panning and zooming in MediaFullScreenViewController, we'll subclass that and tweak it a bit. We'll move the media property to the .h file so the subclass can access it and add a method to allow subclasses to request the recalculation of the zoom scales. now to add the method. We refactored the zoom scale calc out of the viewWillLayoutSubviews method. In general, mandatory methods should be short and not include a lot of actual code, so that you can look at them and know all the things that happen in the program instead of having to read through it all then and there. New MediaFullScreenViewController subclass time, CropImageViewController. It'll have a basic delegate pattern and initializer. Pretty straightforward. Another controller passes it a UIImage and sets itself as the crop controller's delegate, the user sizes and crops the image and the controller passes a new image back. In the .m we'll import the crop box, Media, and the UIImage utilities. Also gonna need properties for the crop box and a bool for later. Superclass uses a Media item, we make a new one from the image. We'll also init the crop box. viewDidLoad will be pretty short- the superclass does most of the work. We need to set clipsToBounds to YES so the crop image doesn't overlap other controllers during nav controller transitions, add the crop box to the view hierarchy, create a crop image button, and disable UINavController's behavior of adjusting scroll view insets. Relatively simple compared to many of our ViewDidLoads for this sort of thing. Our viewWillLayoutSubviews is only going to lay those out and modify superclass behavior. So, ours sizes and centers cropBox, reduces the scrollview's frame to the same as the cropbox, and disables clipsToBound so the user can still see the image outside the crop box. Now we handle the cropping itself. We use imageWithFixedOrientation and imageCropedToRect methods from the last section- we'll make the rect based on the scroll view's panned and zoomed location and pass it in, then call the delegate. Done refactoring. There it is. 1713 end video 1 1713 start video 2 We use ALAssetsLibrary to get at the images and it's up to us to choose how to display them. We'll use UICollectionView to display them in a grid, like the UI in the photos app. UICollectionView mimics UITableView but is more flexible. We'll use a new subclass. In our .m file we'll import ALAssetsLibrary and the crop view controller we made. We'll add a few properties an declare that we conform to the CropImageViewControllerDelegate protocol. library is the user's entire collection of photos and videos. groups will be an array of ALAssetsGroup objects- each album in the photo library is an ALAssetsGroup. arraysOfAssets will be an array of arrays, each nested array containing ALAsset objects from its corresponding album. Collection views can have any layout, so there's a separate class UICollectionViewLayout which manages this layout. Apple's provided a subclass called UICollectionViewFlowLayout to organize items into a grid with optional header and footer views for each section. In viewdidload we'll register the default classes for cells and "supplementary views", like headers and footers. We also set a background color and make a cancel button. At layout time we calculate the size of each cell. We want to fit as many as possible on each row without going below 100 points. We don't put any spacing between cells and we set our header to be 30 points high. Okay. Now to display the images. in viewWillAppear we ask the library to enumerate through all of the groups (ALAssetGroup), for each we'll add the group to self.groups. We then enumerate through the assets in each group and add them to the array. If the request to enumerate groups fails for some reason we alert the user. This is the only use of self.library aside from the init. We have to keep it as a property so the objects 'cause the objects stop giving out info if the library is deallocated. We'll clear images off the screen when they're no longer displayed to save memory. 1757 end video 2 2105 Start video 3- Collection View Delegate and Data Source Methods Now we have to implement the collection view delegate and data source methods. We need to tell the collection view how many sections there are and how many items per section. Given a section and row in the form of an indexPath we need to produce a collectionviewcell for the collection view to display on the screen. We'll have one image view taking up the entire cell, with a rendering of the thumbnail inside. similarly, given a section we need to provide a UICollectionReusableView that represents a section header. Nearly identical, with UILabel instead of UIImageView. There's a new thing there called the NSTextEffectLetterpressStyle which applies a letterpress effect to the text. 2129h end video 3 2131 start video 4- Responding to Image Selection When the user taps a thumbnail we'll get the full resolution image and pass it to the new crop controller we made. and if the user crops an image we'll inform the image library controller's delegate. Next is our last big section on adding the images library controller, so we'll call it on that one. 2137 End video 4 2141 start video 5- Adding the Images Library Controller Two places to add this new controller- in the camera controller when the user taps the right button in the camera toolbar (the starboard button…), and in the primary view if the user taps the camera button but doesn't have a camera available. In camera controller, import the image library controller and declare that it conforms to the delegate protocol. We'll push the view controller on the navigation stack when the user presses the right (starboard) button. When the image library controller hands us an image we'll pass it to the camera controller's delegate. Now, in ImagesTableViewController we'll do a similar thing. Updated the imports and delegates, changed the pragma mark for what we're including now, and now we'll update cameraPressed to display the different controller if the camera's unavailable and implement the delegate method. Just have to implement the delegate method. Changed my mind on the liking heart animation. I applied for a dev account to test this, but it looks like it takes a little while. So, in the interim, onwards and upwards! 2204 end video 5 and section

20150323 0138qtime 1738CST Bloc section 38- Blocstagram- Taking Pictures 0140h start Blocstagram Taking Pictures Video 1- CameraViewController/CameraToolbar intro In this section we'll build a view controller that lets the user take a square picture. We'll use the AVFoundation framework, for playing, saving, editing and encoding photos, videos, and sound. How to use objective-c categories to extend the functionality of a class, and some core graphics functionality for rotating, resizing, and cropping images. First, we'll build some views for users to interact with. Toolbar view first. This should be similar to the toolbar we built in the web browser. Added some graphics. The toolbar will have three buttons- custom right and left, and a camera lookin button in the middle. image names for the icons on the side buttons will be passed in the initializer, initWithImageNames:. The delegate will inform the view when the buttons are pressed. .m file time. Starting by declaring properties for the three buttons, plus two views used to customize the appearance of the view. In the initializer we'll create all these objects and add them to the view hierarchy. We add targets for the buttons, have a default image name for the camera button, and the other two images will be passed in us. in layoutSubviews we'll determine the positioning of these items. Spread em evenly across the horizontal axis, and use a CAShapeLayer and UIBezierPath to round the top left and right corners of the purple view behind the camera button. And finally we need to inform the delegate when the buttons are tapped. Creating views and the delegate pattern look pretty familiar by now. End Blocstagram Taking Pictures video 1 0212h Start Blocstagram Taking Pictures Video 2 0213h CameraViewController Camera View Controller using this toolbar is the next item on our agenda. Users will use the view controller to take pictures. Interface first. Simple delegate property and accompanying protocol to inform the presenting view controller when the camera view controller is done. Got some importing to do. Adding the properties and declaration of which delegates cameraviewcontroller conforms to. imagePreview will be a view that shows the user what the camera sees. session is an AVCaptureSession object- coordinates transfer of data from inputs to outputs. captureVideoPreviewLayer is a special type of CALayer- we used those in our like button. They're like photoshop layers on your app, but animatable. AVCaptureVideoPreviewLayer displays video from a camera. stillImageOutput will capture high quality images from the cap session's input (camera). HorizontalLines/verticalLines are arrays that will contain thin white UIViews putting a 3x3 photo grid over the photo capture area. topView and bottomView are UIToolbar objects, used to adding small buttons usually, but here for their unique translucent effect. cameraToolbar will store the cam toolbar created earlier. end Blocstagram Taking Pictures Video 2 0232 start blocstagram taking pictures vid 3 2207 ViewDidLoad for Camera Our initital setup of this view will be a bit longer than normal, so we'll split viewDidLoad into four sections. 1. creating all the views 2. adding the views to the view hierarchy 3. setting up image cap 4. creating a cancel button in the toolbar. That was annoying. Rectifying the implications of a typo naming a class last night. adding views to the view hierarchy next. The order of those is important- the views added later will be on top. self.horizontalLines/self.verticalLines are nil, so we'll override their getters with some white views. Now to set up the image capture. New vid for this, interesting and new stuff. 2227 end video 3 2228 start video 4 - setting up an AV capture session Here's how we set up an AV capture session. A line in viewDidLoad for our custom view controller. Calls our custom method. Custom method. Alloc/init a new AVCaptureSession object. Change the presets after you know what you're doing. For now, high will suffice. Here, we make a new capturevideopreviewlayer alloc/init'd with our self.session. We set its 'gravity' to resizeAspectFill, which is equivalent to setting a UIImageView's contentmode to UIViewContentModeScaleAspectFill- just makes the view fill up the screen. We call addSublayer, which is like addSubview. Now things get a bit more complex. We're going to ask the user for permission to access the camera by calling [AVCaptureDevice+requestAccessForMediaType], and do it asynchronously in case the user takes a while to grant permission. Once inside the completion block the user has either accepted or declined our access- indicated by *granted. * If granted == YES, we create a device representing the camera and providing data to the AVCaptureSession through an AVCaptureDeviceInput object we create next. The input is added to our capture session, we create a still image output that saves JPEG files, and we start running the session. We also set a delegate for the UIAlertView we present if there's an error. We need to respond to the delegate method by informing the presenting controller that we'll be unable to get an image. And that's how we handle setting up the image capture in a specific view of our app. 2247 End video 4 2247 start video 5 - creating a cancel button We'll create a cancel button in case they don't want to take a photo. And we need to inform the delegate via event handling. Now we'll lay out these subviews. The top and bottom views should be present over the areas of the photo that won't be saved. the horiz/vert lines are distributed evenly over the photo area, and self.imagePreview and self.captureVideoPreviewLayer are configured to take up all the space in the view controller's primary view. The camera toolbar will be at the bottom. Now, we just need to get the view controller to respond to the three button taps. This is more complex than it looks. We'll have a left button that flips between the front and rear cameras, a right camera toolbar button that opens a different view to allow the user to select a photo from their library, and before we can take a photo we'll need methods for rotating, resizing, and cropping. We'll do those things next. 2304 End video 5 2304 start video 6 - how to flip between cameras. Starting with the left camera toolbar button to flip between front and rear cameras. we get the current input as well as an array of all possible video devices. If there's more than one we switch to the next one or to the begining if we're at the end. Once we get our new device we try to create an input for it. If creating the input succeeds we make a nice dissolve effect. 2318 end video 6 2318 start video 7 - Responding to the right camera toolbar button to open up a photo gallery. We'll save that for the next checkpoint. Placeholder method for now. 2320 end video 7 2320 start video 8- prereqs to taking pics- rotating, resizing, and cropping images. Use of Categories. Categories are described in Programming with Objective-C- Customizing existing classes. They are useful when you wish to extend an existing class by adding behavior that is useful only in certain situations where it doesn't make sense to add the utility behavior to the original class interface. Categories let you add your own methods to existing classes. We're adding functionality to UIImage. That was mostly in C- see the lack of * before the names of things. transform holds an affine transformation matrix- a grid of numbers like a spreadsheet that describe how to rotate, flip, scale 2d images. Linear algebra term. Once we've created transform we create a CGContextRef (a bitmap graphics context), like a blank canvas we scale the image to support retina displays apply transform to the drawing context with CGContextConcatCTM and draw the transformed image from the graphics context using cgcontextdrawimage. We then create the UIImage to return from the CGImageRef then we have to release the objects 'cause C is dumb like that. Then we return the UIImage. 0141 end video 8 0142 start video 9 Resizing, Rotating, Cropping cont'd The aspect ratio of the iOS device's screen is not the same as the aspect ratio of the iOS device's camera, so we need to resize an image to the aspect ratio of the screen in order to make the cropping rectangle accurate. Cropping is pretty simple- CGImageCreateWithImageInRect does most of the work. We use that to create the cropped image, convert to UIImage, release the memory, and return the UIImage. 0222 end video 9 0237 start video 10 Integrating image category work into CameraViewController and Taking Pictures Finally back to CameraViewController to take the picture. First, we need to find the right AVCaptureConnection. This represents the input-session-output connection. We pass the connection to the output object so it knows which input to retrieve from, and it returns a completion block with the image in the form of a CMSampleBufferRef, which can contain a variety of media-related data. We know it's a JPEG so we can convert it to NSData and UIImage. We fix the orientation, and scale it using 2/3 of the UIImage category methods in UIImage+ImageUtilities.h. Then we calculate the CGRect of the white square (gridrect) and make sure it's centered (croprect). We pass that to the final method to crop the image in the shape of a square. Finaly we call the delegate method with the image. Camera button should now capture the correct image. 0253 end video 10. 0253 start video 11 Add Camera Button to the Images View Controller Last thing, add a camera button to the images view controller. In viewdidload… We'll present the view controller within a navigation controller when the button is pressed, and dismiss it with a note when the delegate method is called. Now, if we have an apple dev account we could run the app. I don't and I'm not buying one. We'll see what the simulator can handle. Nothing! So we'll call it for now. The assignment is more UIImage category work I can't test out, so I'm just moving on. 0332h End video 11.

20150321 2217qtime 1418CST Bloc section 37- Blocstagram- Comment View Start Blocstagram Comment View video 1 Super sick of blocstgram. Next section we'll integrate the iphone camera, so that might be fun. For now there's even more views and animations in views to play with. Ugh. Anyway. Now that we can all see how excited I am, lets get going! New view. Keeping it decoupled from our model, so we'll make sure it doesn't know what a Media or Comment is in our local paradigm. new class ComposeCommentView, a subclass of UIView. The delegate protocol will inform the delegate when the user star's editing, updates the text, and presses the comment button. This is going to have much in common with our like button- click it and start an animation to a changed view, when you're done post the result and display a different view. There's going to be an extra step in the middle where after clicking the animation brings you to a new view, like our earlier mediafullscreenviewcontroller. Lets keep trucking. We also have a bool isWritingComment which determines if the user is currently editing a comment. text contains the text of the comment and will allow an external controller to set the text. a controller can send this view stopComposingComment if some external event means the compose workflow should end and the keyboard dismissed. On to implementation. I feel like it's quite obvious that my heart's not in this by the lengthy pauses while i do other work on the internets. 'other work.' 2246 end video 1 2246 start video 2 Our view will be composed of a text view and a button, so we'll need properties to store those and to declare that we conform to the uitextviewdelegate protocol. We'll create and configure these objects and add them to the view hierarchy in the initializer. Also, we'll create a new method to generate an attributed string for the button text. Okeydoke. Slow but steady. That's the watchword for this section. self.button is a subview of self.textview, not self. Helpful for wrapping long comment text around a button. so, we set the delegates and targets after creating both objects, and added them. This is the provess. There's a new thing here- the NSKernAttributeName, which specifies the character spacing. We need to layout the views so it looks correct. While the user is scrolling we'll have the comment button gray on the left, and when they start editing it'll fade right and turn purple. 'Cause we can. This stuff goes in layoutSubviews. Background colors and frames are updated based on current value of isWritingComment. After the conditionals we make a CGRect bigger than the comment button, convert it into a UIBezierPath, and add this to the text view's text container's exclusion paths- so the text view won't draw text that intersects with this path. The text wraps instead. Almost done with the view, just need to implement the rest of the code from the interface. If we're told to stop editing, dismiss the keyboard. and if isWritingComment changes, update the view appropriately. here we provide both an animated and immediate way to update the view. Setting isWritingComment directly calls the animated variant passing NO for the animated variable. Within the animated variant we store the new setting and call layoutSubViews to update the view positioning either with or without an animation block, as appropriate. 2359h end video 2 2359 start video 3 when text is set we update the text view and determine which mode is correct depending on if there's any text. we also set userInteractionEnabled to YES. It'll be set to NO when uploading a comment to the API to make sure the text field is enabled if the user scrolls to another cell. When the button is pressed we want to either: if the user hasn't started writing, bring up the keyboard, or if the user has written, send the comment to the API. using the UITextViewDelegate protocol to inform the delegate of user actions, and update isWritingComment appropriately. Whoops, left the game running while i bounced. 20150322 0128 end video 3 20150322 2134 start video 4 now we need to update mediatableviewcell to include this view. This property in media.h will store the comment as it's being written. added the relevant delegate methods. Now we add a public, readonly property for the comment view and a similar stopComposingComment method. In the .m file we need to import it and declare that we conform to its delegate. We also need to redeclare the property as writable in the .m file, since the one in the .h file was readwrite. In the initializer, we add the comment view after creating it. Then we add it to the view with constraints. Now, when calculating height, we should use the bottom of the comment view instead of the comment label. If the table cell is created or reused we need to update the text on the comment view in setMediaItem. And we implement the delegate methods and stopComposingComment. In both commentViewDidPressCommentButton and commentViewWillStartEditing: the cell tells its delegate (the images table controller) that a comment was composed or that the user began editing. in commentview:textdidchange we just hang on to the text written so far in temporaryComment. This allows a user to scroll up and down the table without losing their partially written comments. If another object tells the cell to stopComposingComment the cell passes that message along to the comment view. 2206h end video 4 2206h start video 5 We need to add a method to the data source to handle comments. In the .h file. This implementation will post the method to instagram's comments endpoint ( If it succeeds it'll refetch the media item with the new comment. If not, it simply reloads the row. This is what we were supposed to do for the assignment in the last section. And there's a whole section about it here, just with some animation stuff added. Seems a poor idea to me. Posting again. Similar procedure to our other times: make a string urlstring which consists of the formatted "media/(mediaitem.idnumber)/comments. Make an NSDictionary called parameters consisting of the access token and the comment text. Use our instagramoperationmanager to POST the urlstring consisting of the parameters (incl our access token and the comment text). If successful, use the block consisting of AFHTTPRequestOperation to change the mediaItem.temporary comment to nil, make a string named refreshmediaurlstring populated with the media/media.idnumber, another dictionary with the access token, send it to the instagram operation manager and ask it to get the new media item. If it doesn't work, reload the media item. Also send an error and the response to the log. 2233 end video 5 2233 start video 6 Now to update the images table controller. Starting with properties for the comment view and keyboard height adjustments. Next, in viewDidLoad, request notifications of the keyboard appearing and disappearing. Also enabling UIScrollViewKeyboardDismissModeInteractive, allowing the user to slide the keyboard down like in the message app. Those notifications will call keyboardWillShow and keyboardWillHide before the keyboard shows or hides. We should unregister for these notifications in dealloc. UITableViewController has some built-in logic for handling keyboard appearance but it doesn't work on large cells like ours. So, we need to disable the built-in functionality by overriding the two methods without calling super. We'll minimize jerky scrolling by accounting for the comment view in the height estimation. If a row is tapped, we'll assume the user doesn't want the keyboard. we need to respond to the new delegate methods we made. There. Now, if the user starts composing a comment we save a reference to the comment view. If they press the comment button, we tell the API to send a comment. Two more big code chunks and we're done here. Handling keyboard events. Implementing keyboardWillShow: and keyboardWillHide. When the kyboard shows we need to determine if the keyboard will obscure the comment view's text box, for example if the user taps a comment on the lower half of the screen. If the keyboard will obscure the comment view, adjust the table view's content insets and offset to move the comment view directly above the keyboard. If we make any changes, save them for later so we can undo them when the keyboard hides. code time. Stepping through that. We get the keyboard's frame and the comment view's frame, and make sure they're in the same coordinate system. If they keyboard would be higher on the screen than the comment view, we account for the positioning difference. If the two frames intersect, we adjust the height by the amount of their intersection. Finally we animate the changes and store the adjustment for future use. When the keyboard hides, we reverse the changes. Got some errors to troubleshoot. Saving those for a moment later. The view seems to work well, though. 2329 end video 6 20150323 0036h start video 7 Discovered the problem- as of dec 2014 instagram only grants POST access for comments to business applications. I'll save, upload, and move on.

20150320 2116qtime 1316CST Bloc section 36- Blocstagram- Like Button working here to make a 'like' button for our app. We'll get to tie into the instagram API again for that and make a little graphic and some fun stuff. We'll use Core Animation, a framework by apple for drawing stuff. Should be fun. We've got a packet of images from Bloc to assist with this one, and we just dragged and dropped them into the images.xcassets file. We'll be working with Core Animation here. Core animation renders graphics and creates animations- it's built into iOS and every animation you see uses core animation under the hood. Some basics: Visual content is represented by layers, using the CALayer class and subclasses thereof. Animations are made selecting before and after values for the CALayer properties. So, you rotate the layers, make them opaque, fade them between colors, etc. The animations are CAAnimations and its subclasses. Lets get rolling. We'll start by making a circular spinner. Started with a new UIView subclass. Some properties there. In the .m we're adding a property for a CAShapeLayer. We'll create circleLayer by overriding the getter and creating it the first time it's called. This is known as Lazy Instantiation. Mass of code time. Okay, piece by piece. The first line calculates a CGPoint representing the center of the arc- our arc is an entire circle. Then arcCenter is used to construct a CGRect which our spinning circle will fit inside. Here we make a UIBezierPath object- a bezier path is a path which can have both straight and curved line segments. Ours makes a new bezier path in the shape of an arc with the start and end angles in radians. our smoothedPath is a smooth circular path. Here we crate a CAShapeLayer, a core animation layer made from a bezier path. We set its content scale, just like UIImage's scale, 1.0 on regular screens and 2.0 on retina. Frame is set to rect from earlier. Center of the circle should be transparent so we can see the heart, and the border to be the defined stroke color. lineCap specifies the shape of the ends of the line, and lineJoin specifies the shape of the joints between parts of the line. finally we give the layer the path from our UIBezierPath object. Next we'll make a mask layer and set its size to be the same. Mask layers change the opacity of its layer's content. Our image, angle-mask, looks like this: and that'll allow our circle to have a gradient on it. Now we spin the mask. There's the mask definition. here's the spinning. Completes a spin every second- animationduration is 1. We specify a linear animation as opposed to a geometric which will look like it's easing in and out. We animate the layer's rotation transform from 0 to 2pi. One full circular turn. WELCOME BACK TO GEOMETRY CLASS We repeat an infinite number of times. fillMode specifies what happens when the animation is complete- kCAFillModeForwards in ours leaves the layer on screen after the animation. Then we add animation to the layer. Might be fun to play with autoreverses. Next we animate the line that draws the circle itself. Two CABasicAnimations- start of the stroke, and end. Both are added to CAAnimationGroup which allows multiple animations to be grouped and run concurrently. We add the animations to the circle layer. And we're done building the animation. 2204h. end video 1 2205 start video 2 Creating a method to ensure that the circle animation is positioned properly. Called from a few places in our finished product. There. That just positions the circle in the center of the view. When we add a subview to another view using [UIView -addSubView:] the subview can react to this in [UIView - willMoveToSuperview:], so we'll implement that to ensure our positioning is accurate. Now we'll need to update the position of the layer if the frame changes. if we change the radius of the circle that will affect positioning. We can update that by recreating the circle layer any time the radius changes. We'll inform self.circleLayer if the other two properties, stroke width or color, change. Finally, we'll set some default values in the initializer and provide a hint about our size. That's it! Circular spinning view complete. Now to make a like button to use it. 2218h end of video 2. 2219 start of video 3 new class called LikeButton, a subclass of UIButton. Our header file will define four possible states the button might be in and expose a property for storing this state. In the .m file we'll import the spinner view class, define the image names, and make a property for storing the spinner view. In the initializer we'll create the spinner view and set up the button. Some new properties here- contentEdgeInsets provides a buffer between the edge of the button and the content, concentVerticalAlignment specifies the alignment of the button's content. By default it's centered, but we want it at the top so that the like button isn't misaligned on photos with long captions. We set the default to not liked, as well. Spinner view's frame should be updated whenever the button's frame changes. And now we write code that updates the button based on the set state. There we go. Updates the button's image and userInterctionEnabled property based on LikeState passed in. Also shows or hides the spinner view as appropriate. 2237h. End of video 3. 2238h. start of video 4 Now we're updating the media model to track like state. The button is just a view- shows what it's told. We'll need to pass it the info on whether the user has liked the image. start by importing the like button into media.h so that the likestate, list of possible states, is defined. Adding a property to keep the media item's state. in the .m, figure out whether the user has already liked the image. This goes in initWithDictionary. adding appropriate encode/decode calls… Now media items know whether they've been liked! Lets add the button to the table cell. In the delegate protocol in MediaTableViewCell.h we add a method indicating the button was pressed. In the implementation file (the .m) we import the like button and create a property for it. In the initializer we need to do three things: 1. create the button, 2. add it to the view hierarchy 3. update the layout constraints with its location. In the autolayout constraint we set an explicit width of 38. In setMediaItem we need to display the correct state on the button. When the button is tapped, we inform the delegate. Then we need to update the data source to tell the instagram API when a user likes or unlikes an image. 2256h end video 4 2257h start video 5 Adding a new method called toggleLikeOnMediaItem: to the data source. For the implementation, we need to understand HTTP verbs. Also known as HTTP methods. When we connect to a server, we make a NSURLRequest object. As part of the object we need to specify the action we want the server to take. The most common verb is GET, we've used it in this app a bunch of times. When you GET a URL you are asking for the most recent version of a resource. Responses to GET never create modify or remove data, only transmit it. Some other verbs include HEAD, which requests only the HTTP headers, POST which creates a new resource related to the one at the specified url, PUT which updates the resource at the specified URL or creates it if it's not there, and DELETE which deletes the resource at the specified url. a resource could be anything- a like, a comment, an image, a caption, whatever For our like button, when we like an image we'll create a POST request, and when we unlike an image we'll create a DELETE request. 2317 end video 5 20150321 0526qtime start video 6 Alright, time to code into DataSource for the implementation of the POST request and DELETE to unlike. Okay. Nice block of code. Assume mediaItem.likeState is LikeStateNotLiked (the default), therefore when the user calls this method they're trying to like the image. Set to liking- so the circular animation begins. Make a post request to the url generated at the top of the method, and if it worked update the state to LikeStateLiked. If it didn't revert the state back to LikeStateNotLiked. Either way, reload the row again to update the comment. The delete will be similar but with a DELETE request. And now we need to connect the cell to the Data Source. We do this in ImagesTableViewController.m. Okay! Time for a test run. Hm. Spins a bit and freezes. So, probably a problem with the response to the API request. Yup. Lets open the console. po error in the (lldb) prompt will print the description of the NSError object. The server returned a HTTP 400 error. So. The user has to reauth to grant likeability. The Instagram API authentication docs state that all apps have basic read access by default, and if you plan on asking for extended access such as liking, commenting, or managing friendships, we have to specify these scopes in our authorization request. So we'll need to update the login controller to request these permissions. had to reset content and settings to clear out our data. Sweet! That's enough for tonight. The assignment has a couple of pieces, we'll keep it for tomorrow. 0549h end video 6. 2103h start video 7 The assignment includes 1) playing around with the animation and shape values in CircleSpinnerView. setting autoreverses to YES makes for a weird ghost spinner sometimes. setting the _circlelayer.fillColor = [UIColor to graycolor instead of clear makes a neat radar looking effect. I like it and i'm keeping it. moving on. Part 2 of the assignment is to add a label to mediaTableViewCell that displays the current number of likes. lessee. Made a label, not sure how to set the text. We'll finish the label and its positioning first. Screw it. I'll do that with Steve during our session. Next section is to save the changes to disk when the state successfully changes. Also for steve! Sending it up via github and moving on. I'll see if he has some time to go through this later. Moving on. 2146h End Blocstagram Add Like Button video 7

20150319 0446qtime 2048CST Bloc section 35- Blocstagram- Retrying Image Downloads Quick section here, mostly just coding. Image downloads can fail sometimes because the internet connection is broke. Trains go underground, users are roaming, downloads time out, etc. We'll add a solution for retrying image downloads after the initial attempt fails. Need to track which media items have been downloaded and which still need to be. Start by declaring an enumeration in Media.h Enums were a while ago. typedef NS_ENUM declares MediaDownloadState as equivalent to NSInteger with four predefined values, 0,1,2,3. A MediaDownloadState can be used anywhere an NSInteger can, they're the same. K, now to keep track of an individual media item's download state in a property. An assign property instead of strong- MEdiaDownloadState (AKA NSInteger) is a simple type, not an object. setting a default value in init, otherwise would init to 0 by default. Setting it in initWithCoder too, so that after relaunching the app saved media items will still have a download state. We're determining the download state based on the presence of self.image and self.mediaURL. That way media items with missing images will be retried at least once the following time the app launches. Updating the download state- in datasource we need to update this property as appropriate. first we set the download state to downloadstatedownloadinprogress, a successful image set changes it to hasImage, any error sets the download state to nonrecoverableError. Check for a series of recoverable errors, timeouts and such, and if one of those occurs we set to needsImage. commenting that for the moment. We want other classes to be able to request that images be downloaded, so we add it to the public interface. Instead of downloading all the images as we get the media items we check whether we need the images right before a cell displays. In the images table controller we'll implement tableview:willdisplaycell:forRowAtIndexPath:. Hm. Jumpy. Dealing with that in the assignment. 0518h. To fix the jumpy- add a default value other than 0 for the image height constraint when the image isn't present, or instead of loading images in tableView:willDisplayCell:forRowAtIndexPath:, we could onl load images for the cells currently visible on the screen starting with the scrolling slows down. I'm going with the default other than 0. Looks good! 0523. Growing increasingly weary of sections. Now that Steve has given us carte blanche to mostly ignore assignments, expect quicker turnarounds.

20150317 1417qtime 0617CST Bloc section 34- Blocstagram- 3rd Party Networking Library This is a shorter section focused on installing, configuring, and using AFNetworking, a powerful networking library that eases receiving and sending data. It’s a common iOS library and it can replace some of our code. in case you missed that, i opened up my podfile and added ‘pod ‘AFNetworking’ and then ran $ pod install. There it goes! 1426 i assume it froze… I’ll wait it out. the internet says a)wait, and b) run the following instead of just pod install: pod repo remove master pod setup pod install so… meh. Enough waiting. I’ll run it with —verbose next time to track the progress, but for now… there we go. 1435 So, AFNetworking is a large project that can do a lot of stuff. We’ll be using the HTTP Request Operation Manager, the Response serializer, the request serializer, and HTTP Request Operation. That’s right, we’re getting into the magic nitty gritty here. imported, adding a property for the manager. initialize the ops manager in init… And in the next video we’ll explain that bit and what we’re up to next. 1448qtime. So. Last time we provided a base URL, automatically prepended to any relative urls we provide later. We created a compoundresponseserializer to handle the fact that some requests return JSON and others return images. AFNetworking figures out what to do automagically. We set the imageserializer to 1.0. By default the AFImageResponseSerializer asumes all images on retina devices are double-resolution. That’s not true of the instagram API so we save them as normal. Now, to update populateDataWithParameters:completionHandler: to use the operation manager. That means deleting most of the current implementation and replacing it with implementation that uses AFNetworking. Hoo. Made a parameters dictionary for the access token, addd in any other parameters that might be passed in, and if it’s successful we send it to parseDataFromFeedDictionary : fromRequestWithParameters: for parsing. Now for a similar change while downloading images. Cool, still works!! Now running AFNetworking! This section actually seemed useful. And the right length! I’m getting sick of blocstagram. 2251h 20150319 0352qtime Hopped on with Steve this evening- he fixed the Share button and the refresh. The refresh was actually working fine, just not completing. This method, requestNewItemsWithCompletionHandler, was just missing a completion handler for the case (if self.isrefreshing == no && self.thereisnodataforparamters == no) is not true. The case for that being true had the completion handler. The else let it finish and thus finished the whole thing, getting rid of the spinny circle. The share button just needed an actual definition, and then to define 'share' and add a semicolon to it. Here's the new app. So glad Cupit is there. So, onto the assignment. We're to add code that retries image downloads when you tap on a cell with two fingers, via a UITapGestureRecognizer with numberoftouchesrequired equal to 2. Hm. Retries image downloads. Um? No idea how to check if this is working properly. I'ma call it good and move on. 0432h.

20150315 2125qtime 1325CST Bloc section 33- Blocstagram- Full Screen Photo Viewing and Sharing The last section ended anticlimactically- the big reveal was that things took less time to load. This time around is a little better from a visuals standpoint- we’re adding a bunch of interactivity in the form of maximizing images and such. starting by adding a delegate method to mediatableviewcell which informs the cell’s controller when the user taps on the image. there’s the header change. In the implementation we’ll add a tap gesture recognizer and call the delegate if it’s tapped. declaration that we conform… then a property… and add it to the image view. Hm. That addition on line 67 might be critical to the username and caption label error we’ve been having this whole time… moving on. caps… the method we just added gives the gesture recognizer the firing capability when the cell isn’t in editing mode- when it is in editing mode it allows the user to delete images. And we’re updating setMediaItem so that if the user rotates the device while the full-screen image is showing we’ll avoid issues. Hm! Now there is room for the captions and usernames! we’re adding that bit back into layout subviews though. whaddya know. Fixed it. 2153h. Moving on to creating a full-screen image viewer. need a new viewcontroller subclass for this. just like other view controllers. Custom initializer passed a media object here. Implementation time. Scrollviews are great for zooming as well as sliding content around on rails on the screen- they can handle 2-dimensional panning and a certain amount of 3-d zooming. Okeydoke, creating and configuring a scroll view and adding it as the only subview of self.view, create an image view, set the image, add it as a subview of the scrollview. the contentSize is the size of the content view, aka the content being scrolled around. The frame is set to the view’s bounds. Then we grab two ratios and the smaller one becomes the minimum zoom scale, so they don’t pinch the image so smal that there’s wasted screen space. Max zoom scale is 1 so it doesn’t get pixelated. Now for implementing center scroll view to center the image on the normal scroll view axis. And now for two scroll view delegate methods, one of which calls center scroll view. Adding the capability for the user to dismiss the view controller by tapping on it, and to change the zoom by doubletapping. Got properties, time to initialize in viewDidLoad… Dismisses view controller on single tap, time for zoom on doubletap. If a zoom scale is as small as can be, doubletapping will zoom in- calcs a rectangle using the user’s finger as a center point and zooms in. If the scale is larger, zooms out to minimum scale. We’re done with the view controller, next is wiring it up to the cell. 2246h Now to connect our new view controller with imagestableviewcontroller. Our imagestableviewcontroller doesn’t have an interface defined. wonder if that matters to anybody. set the delegate for when we create/dequeue a cell. Now to implement the delegate method. caps now for runtests! works like a charm. Tap views the image in fullscreen. Tap on fullscreen dismisses. Doubletapping zooms in and out. Pinching on fullscreen zooms in and out. 2257h 0303h 20150316 Now we’re going to make the animation cooler by having the tapped image zoom in and out. We’ll use a new type of object called a *transition coordinator. *Handles complex transitions between two views. New class called MediaFullScreenAnimator. Our first property will let us know if the animation is a presenting animation (as opposed to a dismissing animation.). The second will reference the image view from the media table view cell that the user tapped on. Our first method will specify how many seconds long the animation will be. An NSTimeInterval can be any double number- always specified in seconds. Alright, time for a GIANT METHOD. It starts by being passed a transition context object called transitionContext which gives the method 3 pieces of info: - the view controller the user is leaving, - the view controller the user is going to - a container view which contains the views of both view controllers during the animation. Then we calculate and specify the starting and ending frame for the moving view controller, animate the view controller using the frames we calculated, and inform the transition context when the animation is completed. Let’s code. We built two cases there- one if self.presenting is yes, and one if else. If yes, fromViewController points to the table view controller toViewController points to the full screen image view controller self.presenting == YES, toViewController is the full screen view controller, so we make a new var name fullscreenVC to refer to it. We disable user interaction onf the full screen view controller so users can’t interact with it while the animation is happening we add the views of both view controllers to the transition context’s container view we start calculating frames and perform the animation. first, we calculate the initial frame of the new view controller before the animation begins, wanting it to be the frame of the image view the user tapped on. FullscreenVC’s view is in the coordinate system of transitionContext.containerView, but self.cellImageView is in a different coordinate system (another view controller). To convert we call the method convertRect:fromView to convert a view’s frame/bounds from one view’s coord system to the receiver’s. startFrame is now the frame of the image view the user tapped on, in the container view’s coordinate system. endFrame, we want the full screen view to use the same position and sizing as the regular view controller, so we copy its frame. Now we complete the animation. In general animations in iOS look like: /* Configure how stuff looks when the animation starts */ [UIView animateWithDuration:/* How long the animation takes */ animations:^{ /* Configure how stuff looks when the animation ends */ } completion:^*(BOOL finished)* { /* Do whatever you want when the animation has completed */ }]; We set the full screen view controller’s frame directly over the tapped image, set the image view’s frame to fill the frame completely, animate the frame to endFrame to fill the screen and try to recenter it. Then we tell the transition context the transition is done. The code for dismissing the view controller (after the else) is similar but backwards. Now we need to hook up the animator to iOS. 0340qtime. animator’s imported, and we added a property to track which view was tapped most recently. Now we need to implement the transitioning delegate methods. They vend an animator object to iOS, and when we’re presenting we set presenting to yes but don’t otherwise. Okay. Now we set lastTappedImageView when an image view is tapped and let iOS know the transition uses a delegate. Next we’ll set up image sharing using the delegate protocol we just set up. 0353 We’ll use UIActivityViewController to provide automated sharing depending on which options we provide and apps the user has installed. We’re triggering a share sheet if the user long-presses on an image. Delegate in the header file. Added long press recognizer property. Initialize and add to the image view. When the gesture recognizer fires, inform the delegate… We make sure state is UIGestureRecognizerStateBegan instead of UIGestureRecognizerStateRecognized because if we used recognized the method wouldn’t get called till the user lifts their finger. Now we implement the delegate method in the images table view controller. not sure how to do a long press in the sim. Clicking and holding isn’t working and i don’t know if it’s because my app is broke or the sim requires specific instructions. Ah. Supposed to add a button for it in the instructions as well. After that we can test. 0411h. The assignment is to experiment with different animation durations in the animator… so slooooooow. quick quick quick! to experiment with different minimum and maximum zoom settings in the fullscreen view controller. to look in the UIView class reference at the other methods that begin with animateWithDuration:… and use some of the others in the animator…meh. Not super into the image processing without learning about the vector calc being used to do these things. time to add a button to share. Delegate method in header… ugh so bad at buttons. I’ll send it to steve.

20150310 1101qtime 0301CST Bloc section 33- Blocstagram- Remembering Images and login between launches. We’re going to set up our app remembering the user between app launches and bring them to where they left off. Most important thing to recall is the access token from the instagram API, to prevent us from having to login constantly. These things are remembered in the iOS keychain, encryptes useing AES256. The keychain is complex enough to have its own API. We’re going to manage keychain stuff by installing UICKeyChainStore, an open-source keychain library. We’lluse CocoaPods to install this and manage future iOS plugins. For people new to terminal ops, sudo means use admin privileges, gem is a reference to Ruby (which cocoapods is), and verbose tells it to let us know what it’s doing. Which in this case seems to be… going through the gems and finding that they’ve been moved temporarily a bunch of times. So, 20 gems installed. Now we write a podfile- a list of 3rd party libraries that you want embedded in your app. There’s a list on cocoapods.org. Here’s the text of our podfile- pod ‘UICKeyChainStore’ looks like we might need to update cocoapods.Well, it’s still broken. I’ll ping Steve about it. A little googling revealed that textedit on mac causes errors with ‘smart quotes’ instead of actual quotes. Turning that off in preferences and then setting it to plaintext and we’re giving it another go. Yep, stackexchange was right. well, after seeing that cocoapods hadn’t properly created the right kind of file for the project (we were expecting an .xcworkspace, as opposed to our usual .xcodeproj), i googled the error and found that people have errors here often. The solution is apparently to run pod setup and then pod install. Ran pod setup. Took a bit (3 or 4 mins?) and then I’m trying pod install. 0030h. Cool. That worked! Now Blocstagram and Pods are together, forever. as is typical when working with modern things, there are unexpected consequences to the simplest decisions. Pushing our installed update with cocoapods requires closing xcode as the ‘container’ vanishes. But anyway, got it working Moving on! 0040h. Now we update DataSource to check for and save the access token. Angle brackets import external files. Learning so much! saved the token in registerForAccessToken. And in init, check for the token… And update the app delegate to show the appropriate view upon app launch… time to test! Well, returning to the home screen doesn’t make it go away…. how to quit apps in iOS sim… No idea. Moving on! Saving instagram data to disk, 0114h We’re using NSCoding and NSKeyedArchiver to write the instagram data to the disk and read it when the app launches. NSCoding is a protocol, so objects conform to it when they implement the specific methods and properties. NSKeyedArchiver is an object that converts between saved files and objects that conform to NSCoding. got a new function there, NSStringFromSeletor- converting selectors into strings. Now to add initWithCoder… User now conforms to NSCoding. Time to add pretty much the same code to comment and media. finished the rest of the chapter without videos in a late night coding session. Now i find out the pull-to-refresh has been broken forever.

20150304 1616qtime 0716CST Bloc section 33- Blocstagram- Retrieving Images from Instagram In this section we’ll parse the JSON information from the Instagram API, use it to create objects in our formerly generated classes, download images, and display them in the table view. Busy busy! Our approach to the JSON is to peel it apart like an onion- one layer at a time. Check out our JSON output when we get it from the instagram API. Pretty gnarly. we could instantiate a bunch of items in a dictionary designed to parse the information based on semicolons into things like post numbers, comments, data arrays, profile pictures. Or! We could make model ojects that parse the JSON on their own. Unlike in grade school we’re doing it the easy way. This class, if given the right chunk of JSON (something like the highlighted chunk here), has placeholders for all the items and is looking for them in a small dictionary. Same thing for our comments. realized my filler photos don’t have any comments in em. Lets try again. There’s one of our comments! Anyway note that our comment class will now use the user class to parse that part of our comments. One layer at a time! Media parser time. A bit more complex- Instagram’s JSON has different image resolutions which could be used for things like thumbnail views. It also provides different results depending on whether the image has a caption. Caption… no caption. Next we just need to build one method in Data Source to parse the whole feed using our classes. This little chunk is us informing the key-value observation system that self.mediaItems is about to be replaced, and then has been replaced, so that the table view will reload the data. That’s parsing! Tomorrow we’ll get into downloading images into our media items. 20150305 1600qtime Alrighty, building a method to download our images in *Media*. Gnarly! This follows the same pattern as when we connect to the instagram API- 1. dispatch_async to a background queue so we don’t screw up our UI. 2. Make an NSURLRequest 3. Use NSURLConnection to connect and get the NSData 4. Attempt to convert the NSData into what we’re expecting (a UIImage in this case) 5. if it works, dispatch_async back to the main queue and update our data model with the results. Specifically we use the KVO notification to reload the individual row. So, lets start downloading images as they arrive in parseDataFromFeedDictionary:fromRequestWithParameters whoops, that belonged in datasource. Sleepy. it’ll figure it out. This is pretty inefficient because it tries to download 100 images all at once. we’ll change the code to only download images as the user scrolls through the feed later. Got some minor updates for our table view and table cells- we have no guaranteed images in our media items so we need to update our height constraint logic, estimate height so the autolayout doesn’t freeze up like a jumpy intern trying to figure out how to put 100 images into a frame all at once. We need to check for the presence of the image or self.mediaItem.image.size.width will equal zero. changing the color there. Twas a weird gray before. And rough height estimates. Sometimes it’s better to not calculate everything if you want the app to go fast and to just use arbitrary numbers. We have some more cleanup to do but this vid is getting long so we’ll cut it in half. 1636qtime Broken! We should see images and comments in the initial load. We’ll finish our code and then troubleshoot all at once- lots of troubleshooting to do here. Adding/modifying pull-to-refresh… so nested! we needed to update our init with the new method name. Caught a typo there that would’ve been so annoying. Now we need to update requestNewItemsWithCompletionHandler: (aka pull-to-refresh) to use the method to get newer items. We’ll use the MIN_ID parameter to let instagram know we’re only looking for hitems with a higher id, aka newer items, and we’ll pass back error if we find it. Okay. Currently populateDataWithParameters:completionHandler: calls parseDataFromFeedDictionary:fromRequestWithParameters:, which ignores the parameters dictionary. So we’ll update the method to inspect it and place the newly parsed media items appropriately. Ah. Got interrupted while workin on this method, apparently. cool! Anyway, need to change it now. broken! Lets fix it before we move on- the pull-to-refresh is broken and we’ve only made a couple of changes there. Pull-to-refresh is still broken three days later. Got hung up with a new coworker training and finals for my classes. Back to the Hunt! Ideas in the interim- issue is with view reloading properly from datasource. well, lets clean up the interface a bit for a moment. interesting that we have the same overlapping frames issue from our prior blocstagram build with the stock images. But the view is fixed. Now to check out that pull-to-refresh. Poof! not loading the right image database, looks like. Oh cool! do it twice and it breaks entirely! I am learning to enjoy the hunt. It is like camping- entirely lacking in the amenities of normal, civilized knowing what the hell you’re doing. well, that was it. Had doubled up the method and forgotten a line in the one getting called. 1502qtim 20150308. On to infinite scroll. We’ll ue that property to make sure we don’t make pointless requests. This is a good stopping point, actually. 1505qtime 20150308 Infinite scroll. Now we update requestOldItemsWithCompletionHandler: to check the new property and use the max_id instagram api key. Now we reset thereAreNoMoreOlderMessages if the user does a pull-to-refresh. and we have parseDataFromFeedDictionary check for max_id in parameters. Okay! we have login; display of images, captions, usernames, and comments; pull-to-refresh to check for newer images; and loading older images when scrolling from the bottom. We also know how to download data from the internet and serialize it on a background queue. we’re supposed to push our code prior to the assignment, so we’ll call it good from here. 1524qtime 20150308. The assignment is to fix a bug that when we swipe to delete all images and then pull-to-refresh it causes a crash. Actually i know why this happens as I just had to troubleshoot the same issue- we’re trying to present parameters with an empty table and then asking it to populate the data with parameters incl a min_id from a nil object. We could create a new property checking if the table is empty and returning some text if yes. Well, doesn’t quite work, butdoesn’t throw an error either. I’m ready to call it after three days on this assignment. 20150308 1556qtime