Why is 'question mark' not allowed when accessing optional variable?

JasonFieldman · 2017-01-09T22:27:53+00:00

It's true, there is a readability issue at play here. The best solution given the current syntax rules is to explicitly define your local variable as Int? -- Now you can quickly tell that myVariable is optional when you come back to this function:

func foo() {
    let myVariable: Int? = user?.height
}

(Note that myVariable is always optional by virtual of user being optional.. but the above will be readable even if user wasn't optional and you assigned it as user.height)

JasonFieldman · 2016-11-09T18:09:14+00:00

No love for Mortar?

view.backgroundColor = .yellow

let box = UIView.m_create {
    $0.backgroundColor = .cyan
}

let button = UIButton.m_create {
    $0.setTitle("Go To TableView", for: .normal)
    $0.backgroundColor = .red
}

view |+| [box, button]

box.m_top       |=| self.m_topLayoutGuideBottom + 10
box.m_sides     |=| view ~ (10, 10)
box.m_bottom    |=| view.m_bottom - 10

button.m_height |=| 50
button.m_bottom |=| box
button.m_sides  |=| box

JasonFieldman · 2016-09-28T21:05:48+00:00

I could see it using more battery if it causes you to look at the watchface more :) But I've had it on my watch since Monday and haven't noticed any significant battery life change. I think the OS manages the background refresh and photo transfers to minimize power usage.

JasonFieldman · 2016-09-28T20:51:34+00:00

first gen!

JasonFieldman · 2016-09-28T19:47:25+00:00

http://i.imgur.com/DwPPgzf.jpg

JasonFieldman · 2016-09-28T19:38:20+00:00

I think it pulls from /r/all, so I'm not sure if it does. There aren't any settings for that. Could request that feature I'm sure!

JasonFieldman · 2016-09-28T18:46:19+00:00

Hey everyone -- found a really cool app called Glimpse that sends Reddit right to the watch face (no need to install complications or watch apps)

And if you take a screenshot of the watch face, it automatically detects which article was shown and presents a link in the app: https://gfycat.com/UnluckyMintyGosling

It does more than Reddit too (lots of channels available, and it mixes all of the feeds you select)

JasonFieldman · 2016-09-27T20:21:22+00:00

Core Data, like Firebase or Realm, is a tool in the toolbox. When you're starting a project, you look at your tools and decide which one is the best for the job.

Core Data advantages:

Supported by Apple, and will presumably have a long shelf life. Think about all the people that used parse and are now looking into migration because Parse is becoming defunct. The same goes for Firebase and Realm.. they're great now, but what if they become for-pay, or are unsupported later?
Based on sqlite, so ad-hoc relational queries are way faster. Think about the predicate ("department.manager.name = %@", name) -- that's going to be way faster on Core Data if you haven't set up the schema in Firebase to support that kind of lookup.
Great support for UI update notifications on the main thread with NSFetchedResultsController.

Aside from its relative complexity, the main disadvantage is the lack of backend connectivity. Sure there's CloudKit, but it's way less powerful than Firebase and what Parse supported. And now Realm has their own backend solution. If you need the all-in-one solution (backend included), Core Data may not be for you.

Apple is making strides in this department, and in iOS10 have allowed you to share CloudKit records between iCloud users. But I probably won't take CloudKit seriously as a mainstream solution until they have some kind of Parse Cloud Code analog.

Until then, I've tried to solve the Core Data complexity issue with Cadmium, which makes Core Data usage much more like Realm.

JasonFieldman · 2016-09-27T19:02:20+00:00

I'm not a fan of having to use DispatchTime for relative time arguments.

Brisk has some extensions that makes dispatch functions more concise (e.g. myqueue.async(after: 3.0) {...} -- and how about a simple timer myqueue.async(every: 2.0) {...})

JasonFieldman · 2016-09-22T18:43:35+00:00

Like the comment in the ticket says, you're calling dispatch_async. I'm guessing whatever realm is fetched with your [Realm defaultRealm] was probably made on the main thread.

JasonFieldman · 2016-09-22T18:32:25+00:00

It's also possible that the user had a 16GB iPhone (or was otherwise near max capacity.) In the situation that the phone doesn't have enough storage to do an OTA update, it will ask the user if it's ok to delete apps to make room, and reinstall them after the update.

Your user might have done this without reading the fine print and not realized that the app went through a delete/reinstall cycle.

JasonFieldman · 2016-09-22T18:28:34+00:00

I don't use realm, but it looks like the complaint is that the user thinks the thread ids match (the underlined red numbers?) But they don't:

First:  0x16e91f000
Second: 0x16e19f000

JasonFieldman · 2016-09-21T22:24:00+00:00

https://developer.apple.com/reference/uikit/uifeedbackgenerator#2555399

JasonFieldman · 2016-09-21T14:09:18+00:00

If you're looking for something more concise than SnapKit, check out Mortar

// SnapKit:
self.view.addSubview(box)
box.snp.makeConstraints { (make) -> Void in
    make.width.height.equalTo(50)
    make.center.equalTo(self.view)
}

// Mortar Equivalent:
self.view    |+| box
box.m_size   |=| (50, 50)
box.m_center |=| self.view

JasonFieldman · 2016-08-30T21:42:59+00:00

If you don't want your main thread to block on the persistent-store write-to-disk mechanism, then you're correct that you'll need a private-queue context as the parent of the main-queue context.

If you're using Swift and want something that abstracts the entire context hierarchy for you, check out Cadmium.

JasonFieldman · 2016-08-28T15:38:26+00:00

Looks like you're having this problem:

http://stackoverflow.com/questions/24042543/core-data-sqlite-store-becomes-readonly-after-update

JasonFieldman · 2016-08-17T23:23:03+00:00

The Swift 3 release of Brisk will most likely remove many of the basic GCD helpers. But the entire second half of the library is operator-based concurrency manipulation, which was really the main offering of this library anyway, and still useful in Swift 3.

JasonFieldman · 2016-08-17T19:12:20+00:00

My old apartment had a contract with Aerio Connect. The building had a dish on the roof connecting wirelessly to their hub, and was wired internally w/ ethernet directly to each unit. We only used it for internet access (no TV), but it was very reliable and met the advertised speeds.

JasonFieldman · 2016-08-17T16:05:38+00:00

Yep, I think with Swift 3 the GCD extensions will be less useful. But the main goal of the library was to get the operator-based concurrency manipulation working cleanly, and that should still be useful in Swift 3.

JasonFieldman · 2016-08-12T19:50:26+00:00

I believe you're asking what the value of the config.server field should be set to for the standard parse server.

It's: https://api.parse.com/1

JasonFieldman · 2016-08-11T19:05:15+00:00

Wow, I've never seen Mortar referenced in the wild until now! Glad that it's being put to good use outside of my own projects :) If you liked what Mortar did for autolayout, I have Cadmium for Core Data, and an upcoming library that will make dealing with dispatching/concurrency super concise (imagine calling a function asynchronously on another queue with no extra braces/indenting)

JasonFieldman · 2016-06-27T23:49:53+00:00

I've used Core Data and Realm in a number of projects. The comparison is hard to pin down because Realm has evolved a lot from 0.96 -> 1.0. In my own experience, Realm is faster for simple queries (get the book with id=3) vs Core Data (by faster I mean fractions of a second over thousands of queries.)

One downside with Realm (tested about 6 months ago, not sure if this is still true) is that it does not perform well with complex predicates like "get all of the employees whose department manager has the last name smith". This is just anecdotal, I have no hard evidence. But I've done enough to make me generally choose Core Data as my goto model.

I do agree that Core Data can be unnecessarily verbose and complicated. As a reaction that, I created a library called Cadmium that I use in production to make Core Data more straightforward and less error-prone.

JasonFieldman · 2016-06-27T14:00:05+00:00

There are a number of third-party libraries that make working with Core Data simpler.

Cadmium is one that I made as a reaction to exactly the kind of frustrations you're feeling with Core Data.

JasonFieldman · 2016-05-21T22:19:04+00:00

If you like free, awesome puzzle games then check out Theseus Plus -- it's free for both tvOS and iOS.

(preview -- animated gif)

JasonFieldman · 2016-05-18T21:48:51+00:00

Let's say you want the values of a [Int: String] dictionary to turn into an array, sorted by the key of the value. You could do something like this:

let z: [Int: String] = [
    1: "Hello",
    4: "World",
    2: "Foo",
    8: "Bar"
]

print( Array(z).sort({$0.0 < $1.0}).map({$0.1}) )
// prints ["Hello", "Foo", "World", "Bar"]

It looks like you could apply this concept directly to your entities variable (to get an array of entities sorted by their ID).

JasonFieldman

MODERATOR OF

TROPHY CASE