Core Data with multiple managed object contextsMatthew Morey
When using Core Data for persisting app data multiple managed object contexts (MOC) are often required to avoid blocking UI. Typically you would create a background MOC and listen for changes on the main MOC, merging changes as necessary. With iOS 5, MOCs now have parent context and the ability to set concurrency types. These new features greatly simplify dealing with Core Data on background queues. During this presentation Matt will cover the pros and cons of this new method of dealing with Core Data.
http://highperformancecoredata.com/
Learn how to analyze, debug, and squeeze every last bit of performance out of Core Data. The standard Core Data implementation is very powerful and flexible but lacks performance. In this advanced session we will cover various performance analysis tools, model optimization, and various high performance concurrency models. This is an advanced discussion that assumes you have used Core Data before.
The document summarizes the speaker's experiences with using Core Data and MagicalRecord for building a concurrent iOS application. Some key points include:
1. Core Data objects are not thread-safe and cannot be shared across threads, which can cause concurrency issues.
2. MagicalRecord hides some of the complexity of Core Data but its defaults are not optimal for multithreaded apps and can cause subtle concurrency bugs.
3. Nested managed object contexts introduced in iOS 5 provide a better solution by keeping contexts and their objects confined to individual dispatch queues, avoiding the need for manual thread synchronization.
This document provides an overview of Core Data, an object graph and persistence framework in iOS and macOS. It discusses key Core Data concepts like managed objects, fetch requests, relationships and the Core Data stack including NSManagedObjectContext, NSPersistentStoreCoordinator and NSManagedObjectModel. It also covers common tasks like inserting, updating and deleting managed objects as well as alternatives to Core Data like using SQLite directly via FMDB.
Core Data is an object graph and persistence framework that allows storing and managing objects and relationships between objects. The Core Data stack includes the managed object model, persistent store coordinator, managed object context and persistent stores. Entities are represented by NSManagedObject subclasses and stored in a persistent store like SQLite. The managed object context acts as an in-memory scratch pad and saves changes to the persistent store. Queries use NSPredicate to fetch managed objects. Core Data handles object lifecycles and relationships and automatically saves changes between the context and store.
The world of open source libraries and tools is vast for Android developers. Writing apps using solely Android SDK is impractical. Libraries can help you in many ways. They can speed up your development, save you creating boilerplate code and dealing with platform fragmentation, simplify your code and make it more readable and maintainable. In the talk I’m showing how several truly useful libraries can help a developer.
Presented at MobCon Europe 2017.
The document provides an overview of IndexedDB, a database API for storing structured data locally in the browser. It discusses how to initialize a database and object stores, add, retrieve, and delete data, use indexes to query data more efficiently, and iterate over data using cursors. It also covers key concepts like key paths, key generators, key ranges, and compatibility across browsers. The document aims to explain the basic functionality and usage of IndexedDB.
Core Data with multiple managed object contextsMatthew Morey
When using Core Data for persisting app data multiple managed object contexts (MOC) are often required to avoid blocking UI. Typically you would create a background MOC and listen for changes on the main MOC, merging changes as necessary. With iOS 5, MOCs now have parent context and the ability to set concurrency types. These new features greatly simplify dealing with Core Data on background queues. During this presentation Matt will cover the pros and cons of this new method of dealing with Core Data.
http://highperformancecoredata.com/
Learn how to analyze, debug, and squeeze every last bit of performance out of Core Data. The standard Core Data implementation is very powerful and flexible but lacks performance. In this advanced session we will cover various performance analysis tools, model optimization, and various high performance concurrency models. This is an advanced discussion that assumes you have used Core Data before.
The document summarizes the speaker's experiences with using Core Data and MagicalRecord for building a concurrent iOS application. Some key points include:
1. Core Data objects are not thread-safe and cannot be shared across threads, which can cause concurrency issues.
2. MagicalRecord hides some of the complexity of Core Data but its defaults are not optimal for multithreaded apps and can cause subtle concurrency bugs.
3. Nested managed object contexts introduced in iOS 5 provide a better solution by keeping contexts and their objects confined to individual dispatch queues, avoiding the need for manual thread synchronization.
This document provides an overview of Core Data, an object graph and persistence framework in iOS and macOS. It discusses key Core Data concepts like managed objects, fetch requests, relationships and the Core Data stack including NSManagedObjectContext, NSPersistentStoreCoordinator and NSManagedObjectModel. It also covers common tasks like inserting, updating and deleting managed objects as well as alternatives to Core Data like using SQLite directly via FMDB.
Core Data is an object graph and persistence framework that allows storing and managing objects and relationships between objects. The Core Data stack includes the managed object model, persistent store coordinator, managed object context and persistent stores. Entities are represented by NSManagedObject subclasses and stored in a persistent store like SQLite. The managed object context acts as an in-memory scratch pad and saves changes to the persistent store. Queries use NSPredicate to fetch managed objects. Core Data handles object lifecycles and relationships and automatically saves changes between the context and store.
The world of open source libraries and tools is vast for Android developers. Writing apps using solely Android SDK is impractical. Libraries can help you in many ways. They can speed up your development, save you creating boilerplate code and dealing with platform fragmentation, simplify your code and make it more readable and maintainable. In the talk I’m showing how several truly useful libraries can help a developer.
Presented at MobCon Europe 2017.
The document provides an overview of IndexedDB, a database API for storing structured data locally in the browser. It discusses how to initialize a database and object stores, add, retrieve, and delete data, use indexes to query data more efficiently, and iterate over data using cursors. It also covers key concepts like key paths, key generators, key ranges, and compatibility across browsers. The document aims to explain the basic functionality and usage of IndexedDB.
RubyMotion is great for quickly prototyping apps but it lacks the data modelling tools that Xcode provides. Luckily, using Core Data with RubyMotion can actually be easier and quicker with a little help from some 3rd party libraries.
This document defines a Jersey REST client for interacting with a REST resource called StudFacadeREST located at http://localhost:8080/Stud_Registration/webresources. The client defines methods for retrieving data from the REST resource in both XML and JSON formats, updating/editing data, creating new data entries, retrieving data within a specified range, and removing data entries.
This document discusses various techniques for optimizing Core Data performance and memory usage. It covers topics like thread safety in Core Data, multithreading strategies using notifications or parent-child managed object contexts, different fetch request options like batch size and result type, using expressions and grouping for fetching, prefetching relationships, optimizing predicates by using numerical comparisons first and beginswith/endswith, and printing SQL logs for debugging.
SenchaCon 2016: The Once and Future Grid - Nige WhiteSencha
The Ext JS Grid has been a powerhouse for years, used by thousands of enterprises to deliver robust, data-rich applications to the web. The Ext JS Grid for the Modern Toolkit builds on these years of experience and leverages the full power of HTML5 and CSS3 to provide an extremely flexible and efficient grid for the modern era. In this session, we'll explore some of the key architectural advantages of the Modern Grid. Come and see how you can take advantage of these capabilities to tame mountains of data and give your users the world-class experience they demand.
This document discusses strategies for migrating Core Data models between different versions of an application. It describes what Core Data is and the key objects in the Core Data stack. It then explains automatic lightweight migration, which allows migrating between versions that only contain additive changes, and custom migrations using mapping models, which are needed for non-additive changes between versions. Progressive migration is recommended for migrating through multiple versions by chaining mapping models for each consecutive pair of versions.
This document discusses iOS application architecture and REST client implementation. It covers common iOS concepts like MVC, UIKit, table views and their data sources. It also describes a Comet architecture using a REST API and database to retrieve and display product data in a table. The controller implements the table view data source and delegate methods to display the data and handle user interactions like tapping rows.
AngularJS is a JavaScript MVC framework that uses HTML syntax extensions to add dynamic behavior to web pages. It consists of templates, expressions, controllers, models/scopes, modules, services, and directives that allow developers to build single page applications. Angular compiles templates containing directives and expressions into a view. Controllers define the model/scope and are used in templates to access data and functions. Modules allow reusable features and services provide view-independent logic.
[Srijan Wednesday Webinars] Ruling Drupal 8 with #d8rulesSrijan Technologies
Speaker: Josef Dabernig a.k.a Dasjo
This webinar takes a look at how to automate some powerful backend capabilities for your Drupal site, using the Drupal 8 Rules. Take a look at how D8 Rules can change the way we build sites. Also, learn how you can contribute to getting Rules closer to a stable release.
The document provides instructions on how to implement undo and redo functionality using key-value observing in Cocoa. It explains that KVO allows objects to automatically receive notifications when observed properties change. It also discusses registering observers for specific properties, and handling the notifications in the observer. The document shows examples of implementing both simple and invocation-based undo methods using KVO.
Александр Терещук - Memory Analyzer Tool and memory optimization tips in AndroidUA Mobile
The document discusses memory analysis and optimization tips for Android applications. It introduces the Eclipse Memory Analyzer tool, which can be used to analyze memory usage and find memory leaks. Some key points covered include the low RAM sizes on Android devices, how the garbage collector works, how to analyze an object's shallow size and retained size, finding memory dominators, and common memory leak pitfalls like non-static handlers and large bitmaps stored in static fields. The document encourages analyzing heap dumps in the Memory Analyzer tool to optimize memory usage and find leaks.
The document is a presentation by Clément Sauvage about Realm, a new mobile database. It introduces Realm as being amazingly simple to use, requiring only a few lines of code to instantiate and query. Realm uses object-oriented classes to define schemas and supports common operations like queries, sorting, relations between objects, and migrations between schema versions. The presentation provides examples of adding, querying, and relating objects to demonstrate Realm's ease of use compared to other mobile databases.
This document discusses polyglot persistence using Spring Data. It describes how Spring Data provides a common programming model for data access across different data stores like SQL databases, NoSQL databases and more. It provides examples of defining entities, repository interfaces and queries using Spring Data's JPA, MongoDB and QueryDSL modules. Spring Data aims to improve developer productivity by simplifying data access code and enabling applications to use multiple data sources.
Creating Single Page Web App using Backbone JSAkshay Mathur
This was presented during the workshop on the topic. The complete code of the app that was created during the workshop is available at Github https://github.com/mathurakshay/explore-venues
This document discusses managing state in Ember applications and introduces Redux and RxJS as solutions. It provides an overview of key concepts in Redux like actions, reducers, and combining reducers. It then discusses how RxJS can be used to manage asynchronous logic in a declarative way, including examples of fetching search results, aborting requests, and handling subsequent dependent requests.
This document discusses MongoDB performance tuning. It emphasizes that performance tuning is an obsession that requires planning schema design, statement tuning, and instance tuning in that order. It provides examples of using the MongoDB profiler and explain functions to analyze statements and identify tuning opportunities like non-covered indexes, unnecessary document scans, and low data locality. Instance tuning focuses on optimizing writes through fast update operations and secondary index usage, and optimizing reads by ensuring statements are tuned and data is sharded appropriately. Overall performance depends on properly tuning both reads and writes.
This document describes a database abstraction library for Google Apps Script that allows using different backend databases like Google Sheets, Drive files, and noSQL databases with the same code. It provides caching and handles common queries and operations with only 6 simple methods. Different backends can be accessed by getting a handle to the specific backend using the DataHandler class. Data can also be copied between backends and backends are accessible via a REST API.
The document discusses several software design patterns and concepts used in Zend Framework 3 including singleton, dependency injection, factory, data mapper, caching, and logging. It provides definitions and examples of how each pattern addresses issues like high cohesion, loose coupling, and testability. Key benefits are outlined such as reusability, reduced dependencies, and more readable code.
Google apps script database abstraction exposed versionBruce McPherson
This document describes a database abstraction library for Google Apps Script that provides a consistent API for NoSQL databases. It allows code to be reused across different database backends by handling queries, authentication, caching, and more transparently. The library exposes the capabilities through a JSON REST API that can be accessed from other programming languages. It also includes a VBA client library that translates VBA calls into requests to the JSON API, allowing VBA code to access databases in the same way as Google Apps Script.
This document provides an overview of using Core Data for mobile applications. It discusses creating a data model, using NSManagedObjectContext to manage objects, UIManagedDocument for document management, generating object model classes, and performing basic CRUD operations. It also covers using NSFetchedResultsController to monitor fetch requests and update table views. An example TaskList app is presented to demonstrate these Core Data concepts.
RubyMotion is great for quickly prototyping apps but it lacks the data modelling tools that Xcode provides. Luckily, using Core Data with RubyMotion can actually be easier and quicker with a little help from some 3rd party libraries.
This document defines a Jersey REST client for interacting with a REST resource called StudFacadeREST located at http://localhost:8080/Stud_Registration/webresources. The client defines methods for retrieving data from the REST resource in both XML and JSON formats, updating/editing data, creating new data entries, retrieving data within a specified range, and removing data entries.
This document discusses various techniques for optimizing Core Data performance and memory usage. It covers topics like thread safety in Core Data, multithreading strategies using notifications or parent-child managed object contexts, different fetch request options like batch size and result type, using expressions and grouping for fetching, prefetching relationships, optimizing predicates by using numerical comparisons first and beginswith/endswith, and printing SQL logs for debugging.
SenchaCon 2016: The Once and Future Grid - Nige WhiteSencha
The Ext JS Grid has been a powerhouse for years, used by thousands of enterprises to deliver robust, data-rich applications to the web. The Ext JS Grid for the Modern Toolkit builds on these years of experience and leverages the full power of HTML5 and CSS3 to provide an extremely flexible and efficient grid for the modern era. In this session, we'll explore some of the key architectural advantages of the Modern Grid. Come and see how you can take advantage of these capabilities to tame mountains of data and give your users the world-class experience they demand.
This document discusses strategies for migrating Core Data models between different versions of an application. It describes what Core Data is and the key objects in the Core Data stack. It then explains automatic lightweight migration, which allows migrating between versions that only contain additive changes, and custom migrations using mapping models, which are needed for non-additive changes between versions. Progressive migration is recommended for migrating through multiple versions by chaining mapping models for each consecutive pair of versions.
This document discusses iOS application architecture and REST client implementation. It covers common iOS concepts like MVC, UIKit, table views and their data sources. It also describes a Comet architecture using a REST API and database to retrieve and display product data in a table. The controller implements the table view data source and delegate methods to display the data and handle user interactions like tapping rows.
AngularJS is a JavaScript MVC framework that uses HTML syntax extensions to add dynamic behavior to web pages. It consists of templates, expressions, controllers, models/scopes, modules, services, and directives that allow developers to build single page applications. Angular compiles templates containing directives and expressions into a view. Controllers define the model/scope and are used in templates to access data and functions. Modules allow reusable features and services provide view-independent logic.
[Srijan Wednesday Webinars] Ruling Drupal 8 with #d8rulesSrijan Technologies
Speaker: Josef Dabernig a.k.a Dasjo
This webinar takes a look at how to automate some powerful backend capabilities for your Drupal site, using the Drupal 8 Rules. Take a look at how D8 Rules can change the way we build sites. Also, learn how you can contribute to getting Rules closer to a stable release.
The document provides instructions on how to implement undo and redo functionality using key-value observing in Cocoa. It explains that KVO allows objects to automatically receive notifications when observed properties change. It also discusses registering observers for specific properties, and handling the notifications in the observer. The document shows examples of implementing both simple and invocation-based undo methods using KVO.
Александр Терещук - Memory Analyzer Tool and memory optimization tips in AndroidUA Mobile
The document discusses memory analysis and optimization tips for Android applications. It introduces the Eclipse Memory Analyzer tool, which can be used to analyze memory usage and find memory leaks. Some key points covered include the low RAM sizes on Android devices, how the garbage collector works, how to analyze an object's shallow size and retained size, finding memory dominators, and common memory leak pitfalls like non-static handlers and large bitmaps stored in static fields. The document encourages analyzing heap dumps in the Memory Analyzer tool to optimize memory usage and find leaks.
The document is a presentation by Clément Sauvage about Realm, a new mobile database. It introduces Realm as being amazingly simple to use, requiring only a few lines of code to instantiate and query. Realm uses object-oriented classes to define schemas and supports common operations like queries, sorting, relations between objects, and migrations between schema versions. The presentation provides examples of adding, querying, and relating objects to demonstrate Realm's ease of use compared to other mobile databases.
This document discusses polyglot persistence using Spring Data. It describes how Spring Data provides a common programming model for data access across different data stores like SQL databases, NoSQL databases and more. It provides examples of defining entities, repository interfaces and queries using Spring Data's JPA, MongoDB and QueryDSL modules. Spring Data aims to improve developer productivity by simplifying data access code and enabling applications to use multiple data sources.
Creating Single Page Web App using Backbone JSAkshay Mathur
This was presented during the workshop on the topic. The complete code of the app that was created during the workshop is available at Github https://github.com/mathurakshay/explore-venues
This document discusses managing state in Ember applications and introduces Redux and RxJS as solutions. It provides an overview of key concepts in Redux like actions, reducers, and combining reducers. It then discusses how RxJS can be used to manage asynchronous logic in a declarative way, including examples of fetching search results, aborting requests, and handling subsequent dependent requests.
This document discusses MongoDB performance tuning. It emphasizes that performance tuning is an obsession that requires planning schema design, statement tuning, and instance tuning in that order. It provides examples of using the MongoDB profiler and explain functions to analyze statements and identify tuning opportunities like non-covered indexes, unnecessary document scans, and low data locality. Instance tuning focuses on optimizing writes through fast update operations and secondary index usage, and optimizing reads by ensuring statements are tuned and data is sharded appropriately. Overall performance depends on properly tuning both reads and writes.
This document describes a database abstraction library for Google Apps Script that allows using different backend databases like Google Sheets, Drive files, and noSQL databases with the same code. It provides caching and handles common queries and operations with only 6 simple methods. Different backends can be accessed by getting a handle to the specific backend using the DataHandler class. Data can also be copied between backends and backends are accessible via a REST API.
The document discusses several software design patterns and concepts used in Zend Framework 3 including singleton, dependency injection, factory, data mapper, caching, and logging. It provides definitions and examples of how each pattern addresses issues like high cohesion, loose coupling, and testability. Key benefits are outlined such as reusability, reduced dependencies, and more readable code.
Google apps script database abstraction exposed versionBruce McPherson
This document describes a database abstraction library for Google Apps Script that provides a consistent API for NoSQL databases. It allows code to be reused across different database backends by handling queries, authentication, caching, and more transparently. The library exposes the capabilities through a JSON REST API that can be accessed from other programming languages. It also includes a VBA client library that translates VBA calls into requests to the JSON API, allowing VBA code to access databases in the same way as Google Apps Script.
This document provides an overview of using Core Data for mobile applications. It discusses creating a data model, using NSManagedObjectContext to manage objects, UIManagedDocument for document management, generating object model classes, and performing basic CRUD operations. It also covers using NSFetchedResultsController to monitor fetch requests and update table views. An example TaskList app is presented to demonstrate these Core Data concepts.
Core Data allows developers to work with Swift objects and persist them to storage like SQLite. It provides an object graph and change tracking system so objects can be saved, retrieved, and queried. The Core Data stack includes managed objects, managed object contexts, and a persistent store coordinator that interacts with the backend store. Entities in a data model define the structure and relationships of persisted objects.
Change tracking is a lightweight solution that provides an efficient change tracking mechanism for applications. Typically, to enable applications to query for changes to data in a database and access information that is related to the changes, application developers had to implement custom change tracking mechanisms. Creating these mechanisms usually involved a lot of work and frequently involved using a combination of triggers, timestamp columns, new tables to store tracking information, and custom cleanup processes.
SenchaCon 2016: Ext JS + React: A Match Made in UX Heaven - Mark BrocatoSencha
The document discusses using React with Ext JS by leveraging the @extjs/reactor library. It covers how Ext JS components can be used as JSX tags in React, how to handle events, access component refs, configure complex props, handle updates, and use the @extjs/reactor-webpack-plugin to set up a React app for Ext JS.
The document discusses best practices for using Apache Cassandra, including:
- Topology considerations like replication strategies and snitches
- Booting new datacenters and replacing nodes
- Security techniques like authentication, authorization, and SSL encryption
- Using prepared statements for efficiency
- Asynchronous execution for request pipelining
- Batch statements and their appropriate uses
- Improving performance through techniques like the new row cache
This document discusses connecting an iOS app to a REST API. It covers using a networking library like AFNetworking to make requests, parsing JSON responses, storing data locally using Core Data, and libraries like RestKit that integrate these steps by mapping JSON to Core Data entities and handling background threading. Authentication using OAuth is also briefly mentioned.
CQRS and Event Sourcing are popular architectural patterns that allow you to build effective event-driven micro-services.
The basic idea of these patterns is to record each event that changes the state of the domain model into the event-storage.
This approach allows you to reduce service latency for any data scale, as well as be able to restore the system without losing any data.
This document provides an introduction to React.js, including:
- React.js uses a virtual DOM for improved performance over directly manipulating the real DOM. Components are used to build up the UI and can contain state that updates the view on change.
- The Flux architecture is described using React with unidirectional data flow from Actions to Stores to Views via a Dispatcher. This ensures state changes in a predictable way.
- Setting up React with tools like Browserify/Webpack for module bundling is discussed, along with additional topics like PropTypes, mixins, server-side rendering and React Native.
1. The document discusses adding React components to ASP.NET MVC applications using React JS.NET.
2. It explains how React JS.NET allows bootstrapping a React component tree from a C# view, allowing ASP.NET MVC apps to contain React component trees.
3. The document provides an overview of key aspects like how ReactDOM.Render() is called, using JSX files, fetching data from server-side MVC code, and rendering components on the server-side for performance.
Core Data with Swift 3 provides an overview of Core Data, including:
- Core Data allows managing object graphs and persistence of data to a SQLite store.
- It demonstrates setting up Core Data with Swift including the managed object model, persistent store coordinator, and managed object context.
- Common Core Data operations like saving, retrieving, filtering and deleting objects are shown.
- Using a fetched results controller to wire a table view to a Core Data model is demonstrated.
WOdka is a WebObjects framework that was originally developed in Japan. It includes several frameworks like AuditTrail, JQueryMobileD2W, and ModernistD2W. WOdka has a unified dashboard for developers and administrators. It provides features like logical delete, roles and permissions, and integration with NotificationCenter. WOdka supports modern techniques like CSS3, multi-language, and REST. It is actively developed and maintained by developers in Japan and internationally.
Using the Tooling API to Generate Apex SOAP Web Service ClientsDaniel Ballinger
Presentation from Dreamforce 2014 on using the Tooling API to create increased support for calling SOAP based web services using WSDLs to generate Apex.
This document discusses how ASP.NET manages state across requests in a stateless HTTP environment. It covers the four main types of state in ASP.NET: view state, control state, session state, and application state. View state stores control values and page state between posts. Session state identifies users with a session ID cookie and allows storing data for the user's session. Control state cannot be directly accessed or disabled.
Slides from the Meteor Toronto Meet Up. September 21, 2016.
The session started with cursory introductions of Angular 2 and Redux. We then explore an experimental implementation of an Angular 2 Redux app with Meteor. A high level overview of the approach will be presented and then we will explore the source code guided by the curiosity of the group.
Slides from the Meteor Toronto Meet Up. September 21, 2016.
The session started with a cursory introductions of Angular 2 and Redux. We will then explored an experimental implementation of an Angular 2 Redux app with Meteor. A high level overview of the approach will be presented and then we will explore the source code guided by the curiosity of the group.
VMworld 2013: Extreme Performance Series: vCenter of the UniverseVMworld
VMworld 2013
Justin King, VMware
Ravi Soundararajan, VMware
Learn more about VMworld and register at http://www.vmworld.com/index.jspa?src=socmed-vmworld-slideshare
DISQUS is a comment system that handles high volumes of traffic, with up to 17,000 requests per second and 250 million monthly visitors. They face challenges in unpredictable spikes in traffic and ensuring high availability. Their architecture includes over 100 servers split between web servers, databases, caching, and load balancing. They employ techniques like vertical and horizontal data partitioning, atomic updates, delayed signals, consistent caching, and feature flags to scale their large Django application.
Similar to Create a Core Data Observer in 10mins (20)
Securing BGP: Operational Strategies and Best Practices for Network Defenders...APNIC
Md. Zobair Khan,
Network Analyst and Technical Trainer at APNIC, presented 'Securing BGP: Operational Strategies and Best Practices for Network Defenders' at the Phoenix Summit held in Dhaka, Bangladesh from 23 to 24 May 2024.
HijackLoader Evolution: Interactive Process HollowingDonato Onofri
CrowdStrike researchers have identified a HijackLoader (aka IDAT Loader) sample that employs sophisticated evasion techniques to enhance the complexity of the threat. HijackLoader, an increasingly popular tool among adversaries for deploying additional payloads and tooling, continues to evolve as its developers experiment and enhance its capabilities.
In their analysis of a recent HijackLoader sample, CrowdStrike researchers discovered new techniques designed to increase the defense evasion capabilities of the loader. The malware developer used a standard process hollowing technique coupled with an additional trigger that was activated by the parent process writing to a pipe. This new approach, called "Interactive Process Hollowing", has the potential to make defense evasion stealthier.
Integrating Physical and Cybersecurity to Lower Risks in Healthcare!Alec Kassir cozmozone
The contemporary hospital setting is witnessing a growing convergence between physical security and cybersecurity. Because of advancements in technology and the rise in cyberattacks, healthcare facilities face unique challenges.
Discover the benefits of outsourcing SEO to Indiadavidjhones387
"Discover the benefits of outsourcing SEO to India! From cost-effective services and expert professionals to round-the-clock work advantages, learn how your business can achieve digital success with Indian SEO solutions.
Honeypots Unveiled: Proactive Defense Tactics for Cyber Security, Phoenix Sum...APNIC
Adli Wahid, Senior Internet Security Specialist at APNIC, delivered a presentation titled 'Honeypots Unveiled: Proactive Defense Tactics for Cyber Security' at the Phoenix Summit held in Dhaka, Bangladesh from 23 to 24 May 2024.
1. Build your own
Core Data Observer
Zach McArtor, @zmcartor, http://hackazach.net
2. Wat?
• Small component that notifies us of
NSManagedObject changes/saves
• React to those changes via method invocation
3. Why?
• Sometimes, an NSFetchedResultsController
won’t cut it
• Want to update a tiny piece of UI or run a
background action
• Be reactive!
4. Relevant Notifications
Fired by NSManagedObjectContext
• NSManagedObjectContextObjectsDidChangeNotification
• NSManagedObjectContextDidSaveNotification
5. Subscribe, and ye shall receive
[[NSNotificationCenter defaultCenter] addObserver:self
selector:@selector(contextDidSave:)
name:NSManagedObjectContextDidSaveNotification
object:SomeManagedObjectContext];
6. An NSDict of Changes!
• NSDict keyed by these constants:
• { NSInsertedObjectsKey,
• NSUpdatedObjectsKey
• NSDeletedObjectsKey. }
7. Last step, add a predicate
• Subscribing to didChange/DidSave triggers a
callback for every model save/change. We only
care about a subset of models.
• Abstract notification subscription into Class
• Predicate filter models returned in NSDict. (Protip!)
8. Dealing Concurrency With
• There are different ways to set up a concurrent
Core Data stack :(
!
!
!
http://floriankugler.com/blog/2013/4/2/theconcurrentcoredatastack
https://www.cocoanetics.com/2012/07/multi-context-coredata/
9. Which context to subscribe?
• ‘didSave’ notifications fired during context save
(duh.) Going up chain child->parent
• ’didChange’ notifications fired when context
merges changes (MagicalRecord merges down into default context)
10. Watch out!
• The managedObjects received via notification
may not be in the correct context for use on
main thread.
• Use existingObjectWithId:error: to pull into
correct context
• Subscribe to a single context, don’t listen for
every event within a nested system