Genre: ADV, Fantasy, Furry, Yiff, Anal sex, Virgin, Swimsuit, Crossdressing Censorship: None Developer Publisher: Eliana-Asato HDD 500Mb; 1280x720 The protagonist of the game is called Leslie.
The Problem
Ancient Warfare 3. Age, high cultures, medieval ages, WWI, WWII and compare them to modern and future weapons or just recreate some historic battles. In ancient future, chandler has blended all his skillls and interests to tell a remarkable and original story. Twelve years ago, i was introduced to this promising young scholar who became part of a team working to revise the way african history is told and taught. I am proud to see him finding his own unique voice in this work-a vision of hope born through an understanding of the need for. With OS X Mavericks, Apple ended the era of naming their desktop OS. LICHTSPEER is an action arcade lightspear-throwing simulator based in an Ancient Germanic Future. Co-op mode for 2 players included!
You may be interested in how to wire up or sync CoreData to a remote web service. There are plenty of frameworks to do this, like RestKit, RestfulCoreData, and various defunct libraries (CoreResource, etc.) The problem with these libraries is twofold:
- They assume things about your backend (like 'It's REST!' or 'It has sane queries!' or even 'It parses!') that you know are not going to be true of whatever backend you're working with. Especially dangerous are super chatty protocols that pull down more data than you need, which you know will change halfway into the project when everyone discovers that it's slow, causing you to rewrite a bunch of fetches. Over and over again.
- They require you to run data queries against some arbitrary Cocoa API, which then multiplexes to both CoreData and the backend. This is bad because it's not portable, because if the backend API changes, your code will have to change, and because it's unclear to what extent CoreData features like faulting and proxy arrays 'just work', which you intend to rely on for performance.
As a result of these items, people end up rolling their own sad little sync engine that is just a bit slightly custom for each application, highly coupled to the backend and changes as it changes, and cannot be effectively re-used. Or alternatively, they end up writing their own [MyAPI doSomeKindOfFetch] helper classes that require a lot of thinking in application code to use correctly (caching policies, etc.)
Instead of doing this, you should be using NSIncrementalStore.
Ancient Future Mac Os 7
NSIncrementalStore
NSIncrementalStore is perhaps the best-kept secret in iOS 5. It doesn't show up in any advertising materials, barely rates a passing mention in WWDC tech talks, and has the world's shortest programming guide, at only a few pages. It is so well hidden that I only discovered it very recently. But it's easily my favorite new iOS 5 feature.
Essentially you can now create a custom subclass of NSPersistentStore, so that instead of your NSFetchRequest hitting a local SQLite database, it runs a method you define that can do something arbitrary to return results (like make a network request). This means that fetching remote objects is now as easy as
Even cooler, we now support network faulting. So a code snippet like this:
(Of course, it doesn't have to be. Your custom subclass can fulfill the request however the heck it wants to, including from a local cache.)
So why should you be using NSIncrementalStore? One reason is because it lets you, in application-land, use maximally expressive queries, independently of how bad the backend is today. Perhaps you are working with a terrible backend that only supports 1 API call that dumps the entire database. You can still write powerful queries in your application to request highly-specific data. Then you can respond to those application requests by serving up the highly-specific data from cache.
But when the backend guys finally wake up and realize it's a bad idea and give you five different kinds of requests, you only have to make that change once. The application is still emitting highly-specific queries. You look at the query that the application wants you to serve and select the API call(s) that are most efficient to serve that query, doing whatever sort or filter that the backend doesn't handle as an in-memory step. And you only have to worry about this in one place.
And then as the backend slowly improves, you can slowly take advantage of more and more features. As a slightly absurd example, if some day they let you execute raw SQL (the horror!) directly on the backend, you can write a little SQL emitter that takes CoreData queries and emits SQL that fulfills them. The application continues to work at every step, it just gets incrementally faster as the network traffic gets more efficient.
And CoreData really is a fantastic API to use to talk to remote web services, because it lets you interact with remote objects as if they were local objects. Everybody has forgotten–this was originally the problem that Objective-C / Cocoa was designed to solve! We do not need yet another function call to retrieve a pansy flat representation of a record on a server. ObjC has had a better solution than that for 30 years!
NSIncrementalStore – the unofficial guide
As cool as NSIncrementalStore is, it is missing a lot of love from the Apple documentation writers. (Like any new API, there are undocumented bits, and some scary legitimate bugs, that nobody has gotten around to fixing yet.) The best resources on it are
- The NSIncrementalStore and NSIncrementalStoreNode class reference
- The Incremental Store Programming Guide (which is unfortunately way too short)
- A brief treatment in this WWDC talk which is illuminating
- The various resources on NSAtomicStore (class references, programming guides) are also very helpful in filling in missing details. NSAtomicStore is another type of subclassable CoreData persistent store which was introduced some time ago and is better documented.
- (and hopefully, this blog post)
Init
The first thing you have to do, of course, is override init in your NSIncrementalStore subclass.
Load metadata
When you chain to the super initializer, you will get a loadMetadata: callback. Note, and this is very important: if you fail to set the appropriate metadata here, your incremental store will be improperly initialized. This can result in strange EXC_BAD_ACCESS errors that I see people complaining about on devforums.apple.com.
You are required to set up a NSStoreTypeKey and an NSStoreUUIDKey, and if you fail to do so the incremental store will not be initialized. See the appropriate documentation in NSPersistentStoreCoordinator to learn more about these keys.
Setting up NSPersistentStoreCoordinator
Now, elsewhere in your application, you set up the NSPersistentStoreCoordinator. You tell it to use the custom NSIncrementalStore like this:
Easy as punch. Notice on line 1, we set the string to 'mystoretype', which is the same string we used in our metadata. Failing to make these strings match in my experience sometimes (but not always) causes the persistent store to fail to initialize, with an error message complaining that the strings don't match. So my advice to you would be to store that string in a common location (like in the .h file of the NSIncrementalStore) to ensure that they match.
Handling fetch requests
Now we have to actually handle the fetch requests. This is where things get tricky, because this method
- Can handle fetch requests or save (e.g. write) requests
- Can handle fetch requests that are looking for an object, fetch requests that are looking for a count, or undefined future request types
- Does not actually return any of the object's properties or attributes, which are requested on a different callback
- But is responsible for filtering or sorting on those properties
I'm going to show you just a dummy implementation to get you started, because the full scope of things you can handle in this method is extraordinary.
Note that you are responsible for handling all filters and sorts set on the fetch requests (if your backend does not). This is a lot of work, and I am considering some way to abstract this work so that there is a 'fall back' in-memory sort and filter implementation that can be re-used between NSIncrementalStore subclasses, but I have not yet thought through all the details.
Note that I am returning nil, but (oddly) not setting the error. Why is this? Because due to an undocumented bug in NSIncrementalStore (rdar://10732696), you cannot reference an error created inside an executeRequest:: call from outside the call. So if you do this:
If you want your errors to survive the end of the method, you must make a manual call to objc_retain when you create them. Yes, really. File a duplicate bug with Apple.
Faulting
Allright, so now we've returned a set of fault objects to our application. But what happens when our application tries to access the value of a property? Our NSIncrementalStore class needs a new callback:
This method handles the fault fire of our managed objects (at least for property values). A similar callback exists that fires faults for relationship accesses.
A warning about threads
A ways down mac os. Generally speaking, when you use CoreData, you are interacting with local queries. So calling managedObject.property is not terribly slow, and is something that can probably reasonably be done on the main thread.
However, when you introduce expensive remote queries into the mix, it's not so simple. Suddenly, accessing the property of an object can take a few seconds, or can potentially not be available if you've retired to your concrete-enforced nuclear bunker (or if the wind changes direction and you're using AT&T).
Since you probably don't want to do network requests on the main thread, you are going to be thinking about how to move CoreData code into the background. CoreData threading is a scary and mystical topic, and I've talked to plenty of smart people who don't really understand how it works.
The 'cliff notes' answer is that everything is threadsafe except NSManagedObjectContext (e.g. the thing you use to run queries) and NSMangedObject (e.g. your entities themselves). If you are doing cool things with threads, you need to make sure that you have a separate context for each thread and that you do not pass NSManagedObjects between threads. You can serialize an NSManagedObject to its ID and then get a new NSManagedObject from the new context using the ID.
But a better pattern for most simple applications might be to do all CoreData access on its own thread and use callbacks to retrieve the results of queries. I am considering adding some support for this in my CoreDataHelp project. For example:
I'm still playing around with the syntax. I like the first method quite a lot, but I have mixed feelings about whether wrapping a property fetch is a good idea in practice (or if I should try to rely on pre-caching the property values and only faulting to cache). It may take me a few applications to settle on a pattern.
In conclusion
NSIncrementalStore is one of the best-kept secrets in iOS 5. It has the potential to really change how we interact with remote data on iOS. Today, integrating with web services on iOS is complicated, and doing anything nontrivial requires importing three different (conflicting) JSON parsers, dealing with SOAP fail, importing laughably bad libraries like ASIHTTPRequest that everybody seems to use for everything, doing low-level NSURLConnection hacking that is (at best) very hard to do correctly, and much more. You need about fifteen tabs of documentation open on a second monitor just to get anything done, let alone how badly your application code gets polluted with backend implementation details. Not to mention that one service you're using that has taken it upon itself to produce its own poorly-written ObjC bindings that somehow has made the exact opposite design choices that you would have made for your application, and so you have to fork and hack it pretty aggressively to make it work, changes which will never make it upstream.
Now consider the alternative: we start treating the NSIncrementalStore subclass as the way to wire up remote services to Cocoa. (Either the remote service or the community starts wrapping up GitHub, Flickr, et. al. into NSIncrementalStores as the recommended way to talk to remove services.) Now you don't have to think about whether they're really using REST or only sort-of using REST, or whether their JSON really parses or which set of requests you need to make to get the data you want. All you have to do is understand the object graph they expose (e.g. read a couple of class references), write a couple of NSFetchRequest calls, and you're done. The application interface is the same for every service. This radically simplifies the complexity of writing API-consuming applications.
All the players in the iOS backend space (Parse, Kinvey, and Stackmob) are betting the farm that you would rather talk with Cocoa objects than worry about REST. And they are right. But with NSIncrementalStore, you can graft object support quite beautifully onto arbitrary, existing APIs. And not only that, but you get the power of decades of improvements to CoreData out of the box (like faulting, uniquing, a powerful query language, batched queries, undo support, and much, much more).
But I think that Parse et. al. have much to worry about. NSIncrementalStore is a complex beast, not for lesser developers, but it will gain a lot of mindshare on account of the fact that you can shoehorn existing APIs into it, something that will never be possible with cloud providers. These two forces will cancel each other out. Meanwhile, developers will be concerned about the long-term viability of businesses like Parse, or vendor lock-in, and if they have experience maintaining NSIncrementalStore code for GitHub et. al. they may in many cases consider NSIncrementalStore+REST a better candidate for new APIs than a proprietary service, in spite of its additional complexity. Plus you get decades of cool CoreData tech for free. (One area in which Parse et. al. can still win is through thread management, which is bad with CoreData as it was originally built for fast local queries, but can be fixed through appropriate and lightweight helper classes).
A call for NSIncrementalStore subclasses
So the next time you are reading Yet Another API Manual for consumption in your iOS / Mac application, consider whether the right response is to push an NSIncrementalStore subclass up to GitHub, even if it only supports a small subset of the remote API. API bindings are an area that can really benefit from collaborative, open-source development, even if you are working on an otherwise proprietary Cocoa project. I know that as I consume APIs going forward, I will be spawning lots of OSS NSIncrementalStore projects as a much better way to encapsulate interacting with remote data.
Want me to build your app / consult for your company / speak at your event? Good news! I'm an iOS developer for hire.Like this post? Contribute to the coffee fund so I can write more like it.
So the next time you are reading Yet Another API Manual for consumption in your iOS / Mac application, consider whether the right response is to push an NSIncrementalStore subclass up to GitHub, even if it only supports a small subset of the remote API. API bindings are an area that can really benefit from collaborative, open-source development, even if you are working on an otherwise proprietary Cocoa project. I know that as I consume APIs going forward, I will be spawning lots of OSS NSIncrementalStore projects as a much better way to encapsulate interacting with remote data.
Want me to build your app / consult for your company / speak at your event? Good news! I'm an iOS developer for hire.Like this post? Contribute to the coffee fund so I can write more like it.
Every once in a while, usually once per decade or so, there is one big change that happens in tech that affects everything. Not just that, but it also affects our everyday lives.
A good example would be the introduction of the first iPhone back in 2007, which literally changed how future Phones looked and functioned to this very day. Samsung's Flexible Display Technology from 2011 allowed us to have the Foldable Smartphones that we have today, with many more to come in the future. Tesla's Autopilot has redefined, and will continue to redefine, the car industry. Now…there is another big change just around the corner and this time, it's all about the Processor.
So, get ready for a bit more of a technical video and have those snacks ready and enjoy!
Future Mac Products
Up until 2006, Apple Macs were using PowerPC Processors. PowerPC were a type of Reduced Instruction Set Architecture Processors, which were created in 1991 by, ironically, Apple, IBM and Motorola. This was also known as the AIM Alliance.
The whole idea behind PowerPC Processors was for them to be affordable to the average consumer, rather than for high-end business computers. Additionally, they were intended to not just be very powerful for the average user, but also allow Programmers to very quickly and easily write Code for them. This was all good. From 1994 up until 2006, Apple had only been using PowerPC Processors. But at WWDC 2005, Steve Jobs went on stage to make a big announcement. He announced that Apple will be moving from PowerPC Processors, to Intel Processors.
The main reason for this was ‘Performance per Watt. He said that PowerPC Processors gave Macs around 15 Units of Performance per Watt, whereas Intel was giving them 70 Units, almost five times as much. This is why Apple switched from PowerPC, to Intel Processors. Silver cyber fox mac os. Intel's Chips were more powerful and also consumed less energy, meaning that their machines could be thinner and more portable, which was very important back then. Devices back then were not as thin and portable as they are now.
Now, switching to a new Processor, especially when it has a different Architecture, is extremely difficult and PowerPC and Intel were both based on a completely different Architectures. PowerPC CPU's were based on the POWER Instruction Set Architecture, whereas Intel CPU's were based on the x86-64 Architecture. What this means was that they were speaking completely different languages.
This also meant that every single new program had to be re-written from scratch, but macOS in itself was not capable of running on Intel Processors unless of course, they had a Translator. That Translator was called Rosetta, named after the stone that helped us translate Ancient Egyptian, as the top half of it was written in ancient Egyptian, whilst the bottom half was written in ancient Greek. Anyway, Rosetta translated PowerPC instructions into x86-64 instructions, which meant that most, but not all programs that were developed for the PowerPC era, could actually run on Intel based Macs without the need for a full re-write.
Ancient Future Mac Os Catalina
Escape (itch) (isen0428) mac os. It wasn't perfect, just like when you're translating between two different languages, some expressions just won't translate that well. So, while PowerPC Apps could run on Intel Macs, Native Apps that were designed for Intel Macs first would always run better. That transition actually went very smoothly and fast forward 14 years and up until this point, Apple has kept on using Intel Processors in all of their Macs.
However, Apple is now switching from Intel, to their own Apple Series of Processors and this change will be even bigger than the last one.
Why switch? Isn't Intel the market leader when it comes to CPU's? They are in terms of sales, but they've been having some serious issues in the last few years.
You see, the way a CPU works is that they have these tiny Transistors that can pass electrical current through them, which the CPU then reads as one's and zero's. Modern CPU's have billions of Transistors and the smaller and thinner these are, the faster they can pass the current through and therefore, the faster the CPU. It's like driving a car from NY to LA to deliver a package, compared to driving from your house to your neighbour's house, to deliver the same package. Obviously, the package will get to your neighbour's house much faster as the distance is smaller, CPU's work in the same way.
The size at which the Transistors inside a Processor are measured at is just in a few Nano-Metres. Intel has been using a 14nm manufacturing process and just to give you an idea of how thin those Transistors are, a human hair is around 90,000nm in thickness. A single strand of human DNA is 2.5nm. Intel's has been manufacturing transistors at 14nm, which is pretty incredible. But, Intel has been releasing 14nm CPU's since 2014 and they've been trying to switch to 10nm, the next step in the manufacturing process, since. They've only been able to do it in 2019.
Apple, on the other hand, switched to 10nm in 2017, two years ahead of Intel. Not only that, but Apple has since switched to 7nm in 2018 and will switch to 5nm in 2020, with the upcoming Apple A14 Processors. Apple is already three generations ahead of Intel when it comes to the manufacturing process. To be more accurate, TSMC is, they are the actual manufacturers for Apple's CPU's. Additionally, AMD is also manufacturing on a 7nm process now, being two generations ahead of Intel.
Intel launched 10nm in 2019, but even now in 2020, only ‘Y' & ‘U' Series Mobile CPU's come with it. Desktop and high-end Laptop Processors, such as the H-Series that you would find on a 16' MacBook Pro for example, those are still based on a 14nm process.
Even if you take a look at the 10nm ‘Y' & ‘U' Series Processors, not even all of the models are based on the 10nm process, some are still 14nm CPU's. It's so horribly confusing. The whole point of Intel's 10th Generation Processors was to finally switch to 10nm, but they've only done that on around 20% of their 10th Generation CPU's, the rest are still 14nm. AMD Processors now out-perform Intel quite substantially and they even do it at a lower price.
Not only that, but Apple has improved their own Processors so much, that even the 2018 iPad Pro now out-performs most Laptop Processors from Intel. The iPad Pro has significantly better performance than a 2020 baseline 13' MacBook Pro, it's even better than the higher-end model. The iPad Pro is also significantly thinner than a Laptop and it does not even have a Fan in it, it is all passively cooled, whereas Laptops need to have gigantic Cooling Systems.
These are the two main reasons why Apple wants to move away from Intel. They want better Performance and they want that Performance at a lower power consumption than at what Intel offers, which means that they can make way more portable devices with a significantly better Battery Life. Imagine having an iMac that's as thin as an iPad Pro, or a MacBook Pro that lasts for 20 hours, or more, on a single charge.
But, there is one more reason why Apple wants to switch now. Unlike 2005, when they were just looking for better performance at a lower power consumption, Apple now has the iPhone and the iPad, none of which they had back in 2005. Those devices also run on Apple's own Processors, which means that Apple can now unify their entire line of devices and have any APPS run on the iPhone, the iPad and on the Mac natively, with no changes in the code required. This means that you'll be able to run any iPhone App directly on your Mac including Instagram, Facebook Messenger or basically anything.
Moreover, Mac Apps such as Final Cut Pro X and Logic Pro X will also able to run on iPhone and iPad. In fact, Apple even showed FCP X running on a Mac Mini with an Apple A12Z Processor, the same Processor as in the iPad Pro 2020. While it did have 16GB of RAM, compared to the 6GB on the iPad, and the CPU was likely cooled too, it could actually play three streams of 4K ProRes with effects at the same time, without dropping any frames at all. A 16' MacBook Pro can run around 11 streams of 4K ProRes, which is quite a bit more, this would also be ProRes RAW. But, keep in mind that the A12Z is just a Tablet Processor. Apple already mentioned that they're working on multiple variants of their own CPU's to be used in Macs, which Apple hasn't really showed yet.
However, they did show us this graph that compared their Processors to the current devices that Apple is offering. Whilst Apple's range is quite big, we can indeed tell that they are developing Laptop Processors that are just on par with Intel's lowest-end Desktop Processors, while also having less power consumption than Intel's current Laptop Processors .That equates to a 12' MacBook or a MacBook Air with a 20 hour Battery Life, having more performance than the regular iMac. Now, if we take a look at the upper part of this graph, we can see that Apple's even aiming to make Processors better than any Desktop Processors that Intel has now, with just a bit more power consumption than a current Laptop.
These are very bold claims but I do believe that they can pull this off, especially if we take a look at what they've already achieved with the iPad alone.
Ok, so now that we've covered the ‘Why', what about the ‘How'?
MacOS Big Sur, which is coming out later this year, will be the first macOS that has been developed for both x86-64 Intel Processors and ARM Processors (ARM being the Architecture that Apple's using for their own Chips). Apple will be using the same Rosetta tool that they used back in 2006 to switch from PowerPC to Intel, which is now called Rosetta 2 and will translate x86-x64 Code, into ARM code. This means that you'll still be able to run all of your Intel software on future ARM Macs.
Native apps will still run much better, FCP X was a good example and Apple has also shown Photoshop as well as Lightroom, which were both running extremely smooth. Lightroom was able to open up a massive library of RAW photos without any lag or slowdown whatsoever. On the Mac, I always get the beachball and some lag here and there whenever I do that, so that's crazy.
You're probably wondering, when is this transition going to happen and how would you be impacted?
Well, Apple has said that this transition would take two years. Meaning that by the end of 2022, we should have an Apple Processor in every single Mac that Apple sells, from the MacBook Air, all the way up to the Mac Pro, which is nuts. ARM CPU's have never been designed for sustained workloads but it seems that this concept has been proven wrong, ‘The Verge' reports that Japan has developed a supercomputer using ARM Processors and it turns out that this is now the fastest computer in the entire world, with it also being 2.8 times faster than the previous most powerful supercomputer in the world. So, ARM is definitely looking very promising.
Now, Intel based Macs will still be supported for a number of years, but if you do plan on getting a Mac now, I would highly highly advise you to wait until the end of the year when Apple would be releasing their first Mac with an Apple Processor. Ming-Chi Kuo says that it will be a new 13' MacBook Pro. I'm fine with that, so I can't wait!
I just want to touch a bit on macOS Big Sur. This is really the biggest software update since macOS Yosemite, which changed up the design significantly from the previous design language that macOS Mavricks used. ‘Big Sur' is an even bigger change as it adds a ton of elements from the iPhone and the iPad, to macOS. We even get things such as Control Centre and the same iOS-style Toggles.
While I do really like this design a lot, it kind of looks like it was made for Touch Input first because, well, it was. The iOS UI was made for Touch Input rather than Mouse Input. So, the fact that Apple's adding the exact same design language and the same UI style makes me think that maybe we will see a TouchScreen Mac in the not too distant future. That would be pretty amazing.
The start-up sound is back, which is quite interesting to see, alongside a ton of design elements from iOS. These include the Notification Panel and the indicator that shows amount of battery you have left in hours, is now back. They've also just cleaned up the entire UI a lot.
I do have two main concerns regarding Big Sur's design. Firstly, the UI elements and how they just don't feel right, they were designed for Touch Input. My second concern is the Icons. Apple is calling this a unified design, but they don't look the same. They all have this weird shadow that is on the inside, very strange. We don't have this on iOS and it just looks as if different Icons were designed by different people. The ‘Reminders' Icon has no shadow at all, whereas the ‘Messages' Icon does. Hopefully Apple fixes this by October, when macOS Big Sur is said to be released to the public.
Anyway, I'm definitely looking forward to the future of the Mac and this transition will shape the entire tech industry. It will end up forcing more companies to innovate into the Mobile CPU space and of course, forcing Intel to do something about their CPU offering because at this point, AMD is ahead and it seems like Apple is now ahead as well.