User Scenario based UI testing with KIFYusuke Kita
?
This document discusses using KIF for scenario-based UI testing on iOS. It introduces use case scenarios for navigating between screens and describes how to set accessibility labels and run actions in KIF tests. It also provides code snippets for capturing screenshots and creating GIFs from the tests.
The document discusses Apple's search APIs and how they enable apps to provide rich content to Spotlight, Siri and Safari search results. It covers three APIs - NSUserActivity, App Search and CoreSpotlight - that allow indexing app content and activities to make them discoverable in searches. The document also discusses how to index web content to drive traffic to mobile apps and optimize search results through techniques like keywords, structured data and fast deep linking to improve an app's relevance ranking.
The document discusses limitations and features of using maps on Apple Watch, including:
- Current limitations of WKInterfaceMap include it not being scrollable, zoomable, or able to open Apple's map app. Only 5 annotations are allowed.
- Location services can be accessed by requesting authorization from the iPhone, not the Watch. Handoff can be used if authorization is not granted.
-Annotations use custom images cached from the device rather than the current location. Realm can be used instead of CoreData to share data between watch and iPhone apps.
- A restaurant browsing app was rejected for having limited features, only launching maps. More robust features are needed.
- PagingMenuController and
The document provides information about Swift Core, which includes the core libraries and functionality of the Swift programming language. It lists some of the key Swift libraries like swiftAST and swiftLLVMParses. It also describes the documentation build process and lists important files that define the language like Attr.def, Builtin.def, and MappedTypes.def. The document outlines how to install and develop Swift in Xcode and highlights some core language functions.
Useful and Practical Functionalities in RealmYusuke Kita
?
The document provides an overview of useful functionalities in Realm cocoa, including encryption, migration, and multi-process support. It discusses how Realm allows encrypting database files with AES-256, supports migrating data models between schema versions, and enables seamlessly sharing Realm files between multiple processes. The document also provides code examples and tips for using encryption, migrations, and multi-process capabilities. It recommends reviewing the CHANGELOG, issues on GitHub, and Google Groups for additional help with Realm.
Integrating libSyntax into the compiler pipelineYusuke Kita
?
The document discusses integrating the libSyntax library into the Swift compiler pipeline. Currently, the Swift parser emits both a libSyntax syntax tree and a semantic AST, but libSyntax ignores the AST. The goal is for the parser to fully embrace libSyntax and stop emitting the AST. It describes the existing parsing process, which builds the AST at each step, and explores options for modifying it to also build the libSyntax tree at each step instead of just the AST.
The document discusses the benefits of exercise for mental health. Regular physical activity can help reduce anxiety and depression and improve mood and cognitive functioning. Exercise causes chemical changes in the brain that may help alleviate symptoms of mental illness and boost overall mental well-being.
This document summarizes Yusuke Kita's open source Swift workshop presented at try! Swift Tokyo 2019. The workshop covered getting started with contributing to the Swift compiler, building Swift and SwiftSyntax from source, debugging and testing Swift, building your own tools with SwiftSyntax, writing your own compilers, and tips for working with the open source Swift project. Attendees were encouraged to ask questions during the workshop presentation.
Yusuke Kita presented on his experience contributing to the Swift compiler. He contributed improvements and fixes to the compiler's libSyntax, AST, and SIL components. He encourages others to get involved by taking ideas from and giving ideas to the open source Swift community. Contributions can start small and it's never too late to start. The try! Swift events provide workshops for contributing to Open Source Swift.
This document discusses writing a compiler in Go. It provides an overview of the different modules needed for a compiler, including tokenization, lexing, parsing, AST generation, code generation, and a virtual machine. It also demonstrates these concepts by summarizing the development of a Monkey compiler, with modules for tokens, lexer, parser, AST, objects, evaluation, and code generation. Key takeaways are gaining an understanding of how compilers work, learning more about Go, and laying foundations for static analysis tools.
The document discusses writing an interpreter for a programming language in Swift. It summarizes the key modules of the interpreter including the syntax, lexer, semantic analyzer (Sema), abstract syntax tree (AST), and read-evaluate-print loop (REPL). Code examples are provided for defining token types in the syntax, lexing source code into tokens, parsing tokens into an AST using the semantic analyzer, and evaluating nodes in the AST.
The document discusses the SIL optimization pass called AllocBoxToStack. It begins by providing context on SIL and why it is used. It then explains the difference between allocating values on the stack vs the heap. The main part of the document describes how the AllocBoxToStack pass works to promote alloc_box instructions to alloc_stack by analyzing variable lifetimes and use patterns. Code examples are provided to demonstrate the optimization.
The document discusses SIL (Swift Intermediate Language), which is the intermediate representation used by the Swift compiler. It provides an overview of SIL and how the Swift compiler uses it, demonstrates converting Swift code to SIL, and shows how optimizations are performed from raw SIL to canonical SIL. Examples are given of memory optimizations and how flag settings can control optimizations. In summary, learning SIL provides insights into how the Swift compiler works and is worthwhile for optimization.
The document compares the differences between var and let in Swift's SIL (Swift Intermediate Language). Var uses alloc_box to allocate memory on the heap while let uses alloc_stack to allocate on the stack. Var requires begin_access/end_access instructions to access memory, while let uses direct load/store. Var needs destroy_value to release memory, while let uses dealloc_stack. The key difference is that var uses reference counting for a box on the heap, while let uses stack allocation with direct lifetime management.
The document discusses Swift Intermediate Language (SIL), which is an intermediate representation used by the Swift compiler. SIL allows understanding how the Swift compiler works and enables optimizations. Examples show how a simple Swift function is represented in SIL and how optimizations remove unnecessary intermediate variables. Learning SIL provides insights into the Swift type system and compiler optimizations.
The document discusses various blog posts and resources about learning Swift compiler development, including posts about the Swift compiler architecture, testing, and development environment. It also lists resources on the Swift frontend, lexer, parser, code generation to LLVM IR, SIL, types, and generics implementation.
The document discusses introducing Protocol Buffers (protobuf) in Swift. It begins with an overview of protobuf and how it provides a compact and efficient way of serializing structured data. It then covers how to use protobuf in Swift projects - defining message types in .proto files, generating Swift code from the .proto files, and serializing/deserializing data to and from the defined message types. Key advantages of using protobuf like type safety, shared data models across platforms, and high performance are also highlighted.
Type-safe Web APIs with Protocol Buffers in Swift at AltConfYusuke Kita
?
The document discusses using Protocol Buffers for building type-safe web APIs in Swift. It describes Protocol Buffers as a serialization format that is smaller, faster and safer than JSON. It explains that Protocol Buffers involve defining message types in .proto files, generating code from those files, and then serializing and deserializing data to and from the defined types. The speaker will cover what Protocol Buffers are, their pros and cons, and how to get started with them.
This document introduces CardioMerkari Inc. and their Cardio health kit wrapper library. Cardio is an open source Swift library that provides a simple interface for accessing HealthKit functionality related to workouts. It handles authorization, reading workout data from sensors, and saving workout data to HealthKit. The document provides information on using Cardio such as initializing it with a context, setting up authorization, starting and ending workout sessions, handling sensor updates, and saving workout data.