https://medium.com/nanonets/topic-modeling-with-lsa-psla-lda-and-lda2vec-555ff65b0b05
기본 nlp modeling 기법 개념 설명
lsa만 읽고 이해함
aws 기본 구성 요소
aws iot core ( iot 기기에 대한 기본 작업)
aws iot 1 click (원 클릭에 대응하는 기기에 대한 서비스)
aws iot device defender (iot 기기에 대한 authorization, authentication 작업 제공)
aws green grass
개념이해를 위한 비디오 (local network단위내에서 기기간 서로 상호작용하고 또 이것이 외부 클라우드 서비스와도 상호작용하는 기능을 제공하는 듯)
aws 기본 구성 요소
aws iot core ( iot 기기에 대한 기본 작업)
aws iot 1 click (원 클릭에 대응하는 기기에 대한 서비스)
aws iot device defender (iot 기기에 대한 authorization, authentication 작업 제공)
aws green grass
개념이해를 위한 비디오 (local network단위내에서 기기간 서로 상호작용하고 또 이것이 외부 클라우드 서비스와도 상호작용하는 기능을 제공하는 듯)
original source : https://developer.apple.com/library/content/documentation/WindowsViews/Conceptual/ViewPG_iPhoneOS/Introduction/Introduction.html#//apple_ref/doc/uid/TP40009503
About Windows and Views
In iOS, you use windows and views to present your application’s content on the screen. Windows do not have any visible content themselves but provide a basic container for your application’s views. Views define a portion of a window that you want to fill with some content. For example, you might have views that display images, text, shapes, or some combination thereof. You can also use views to organize and manage other views.
At a Glance
Every application has at least one window and one view for presenting its content. UIKit and other system frameworks provide predefined views that you can use to present your content. These views range from simple buttons and text labels to more complex views such as table views, picker views, and scroll views. In places where the predefined views do not provide what you need, you can also define custom views and manage the drawing and event handling yourself.
Views Manage Your Application’s Visual Content
A view is an instance of the UIView class (or one of its subclasses) and manages a rectangular area in your application window. Views are responsible for drawing content, handling multitouch events, and managing the layout of any subviews. Drawing involves using graphics technologies such as Core Graphics, OpenGL ES, or UIKit to draw shapes, images, and text inside a view’s rectangular area. A view responds to touch events in its rectangular area either by using gesture recognizers or by handling touch events directly. In the view hierarchy, parent views are responsible for positioning and sizing their child views and can do so dynamically. This ability to modify child views dynamically lets your views adjust to changing conditions, such as interface rotations and animations.
You can think of views as building blocks that you use to construct your user interface. Rather than use one view to present all of your content, you often use several views to build a view hierarchy. Each view in the hierarchy presents a particular portion of your user interface and is generally optimized for a specific type of content. For example, UIKit has views specifically for presenting images, text and other types of content.
Relevant Chapters: View and Window Architecture, Views
Windows Coordinate the Display of Your Views
A window is an instance of the UIWindow class and handles the overall presentation of your application’s user interface. Windows work with views (and their owning view controllers) to manage interactions with, and changes to, the visible view hierarchy. For the most part, your application’s window never changes. After the window is created, it stays the same and only the views displayed by it change. Every application has at least one window that displays the application’s user interface on a device’s main screen. If an external display is connected to the device, applications can create a second window to present content on that screen as well.
Relevant Chapters: Windows
Animations Provide the User with Visible Feedback for Interface Changes
Animations provide users with visible feedback about changes to your view hierarchy. The system defines standard animations for presenting modal views and transitioning between different groups of views. However, many attributes of a view can also be animated directly. For example, through animation you can change the transparency of a view, its position on the screen, its size, its background color, or other attributes. And if you work directly with the view’s underlying Core Animation layer object, you can perform many other animations as well.
Relevant Chapters: Animations
The Role of Interface Builder
Interface Builder is an application that you use to graphically construct and configure your application’s windows and views. Using Interface Builder, you assemble your views and place them in a nib file, which is a resource file that stores a freeze-dried version of your views and other objects. When you load a nib file at runtime, the objects inside it are reconstituted into actual objects that your code can then manipulate programmatically.
Interface Builder greatly simplifies the work you have to do in creating your application’s user interface. Because support for Interface Builder and nib files is incorporated throughout iOS, little effort is required to incorporate nib files into your application’s design.
For more information about how to use Interface Builder, see Interface Builder User Guide. For information about how view controllers manage the nib files containing their views, see Creating Custom Content View Controllers in View Controller Programming Guide for iOS.
What is the purpose of UIWindow?
original source : https://stackoverflow.com/questions/18282311/what-is-the-purpose-of-uiwindow
You might want to check out the About Windows and Views section in the View Programming Guide for iOS.
In iOS, you use windows and views to present your application’s content on the screen. Windows do not have any visible content themselves but provide a basic container for your application’s views. Views define a portion of a window that you want to fill with some content. For example, you might have views that display images, text, shapes, or some combination thereof. You can also use views to organize and manage other views.
Also note that an iOS application usually only has one window. An exception would be, if an app displays content on an external screen.
What is Delegation? – A Swift Developer’s Guide – Andrew Bancroft
original source: http://www.andrewcbancroft.com/2015/03/26/what-is-delegation-a-swift-developers-guide/
(개념정리 예를 들어 ios에서 UITableViewDelegate 를 제공한다. 그리고 이 protocol 안에 tableView(_:willSelectRowAtIndexPath:) 와 같은 함수들이 들어있다. 이 함수 tableView(_:willSelectRowAtIndexPath:)를 개발자가 conform함으로써 개발자가 만든 함수가 delegating 하게된다(ios가 수행할일을 대신). 이때 이 함수는 대신 작업을 수행함으로 delegate라고 할수 있다.그리고 ios는 delegator라고 할수있다.이를 통해 얻을수 있는 두가지 효과는 크게 communication과 cumstomization이다 아래글을 읽고 확인)
What is the delegation design pattern?
To read that “delegation is a design pattern that [insert explanation here]” never really clicked with me. Many who are new to programming have not dealt extensively with “design patterns”, so it doesn’t always suffice to define delegation in those terms.
I suspect that since Swift has lowered the barrier to entry for iOS development, many who are new to the platform are also new to coding in general, so here’s my attempt to explain what clicked for me regarding what delegation is:
Design pattern
First, take the phrase “design pattern”.
Design implies architecture. It connotes a strategy for organizing something. Design conveys the method by which components will work together to accomplish an end.
Pattern implies that there is some repeatable process that has honed in around a common thread… a common practice… a predictable method for doing something. “Pattern” gives the impression that such a practice has converged over time into something that is now well-known, well-understood, and commonly used. I imagine a sort of “survival of the fittest” approach to process and practice. Things that didn’t converge or that were weaker in the real world fell away and the strongest survived into this thing we call “pattern”.
A design pattern in software terms, then, is a method for architecting, strategizing about, and organizing an application’s code in such a way that has been found to be commonplace, repeatable, and practically sound over time.
Delegation
Now take the word delegation. Three things come to my mind:
- The verb, “to delegate”, meaning “to give control”
- The noun, “a delegate”, meaning “a person acting for another”
- The made-up noun, “a delegator“, or more properly, a principal, meaning “a person who delegates to another”
In the real world, the word delegation encapsulates relationship and responsibility. A delegator/principal (noun) would delegate (verb) control or responsibility to another person called a delegate.
How could we map this to software? Well, it actually falls in line quite nicely.
Rather than people, we’re dealing with instances of classes (or other data structures like structs, but I’m just going to keep it simple and say “class” to encapsulate the idea). For delegation to occur in software, you’d have a situation where one class (a delegator/principal class) would delegate control or responsibility, here meaning behavioral logic, to another class called a delegate.
How is delegation used?
So yes… delegation is a design pattern. It’s a design pattern that exists on other platforms, but it is one that has been heavily adopted by Apple and is ubiquitous throughout the iOS APIs. It’s a design pattern that shifts responsibility from one class to another, thereby creating a separation of responsibilities and concerns. But what kinds of responsibilities and concerns? How is delegation used in practice?
Communication
In practice, delegation is most often used as a way for one class to communicate to another class. Observing some of the actions that delegates perform from Apple’s own APIs give us clues about this. Take the following samples from UITableViewDelegate as an example:
- tableView(_:willSelectRowAtIndexPath:)
- tableView(_:didSelectRowAtIndexPath:)
- tableView(_:didHighlightRowAtIndexPath:)
Or how about a sampling from UIScrollViewDelegate:
- scrollViewDidScroll(_:)
- scrollViewWillBeginDragging(_:)
- scrollViewWillEndDragging(_:withVelocity:targetContentOffset:)
- scrollViewDidEndDragging(_:willDecelerate:)
My observation of Apple’s APIs indicates to me that one of the intended uses for delegation is to allow one instance to communicate back to some other instance that something will/did happen. The table view or scroll view delegates the opportunity to perform some action in response to some lifecycle event to another class, namely, its delegate.
It’s also worth noting the scope of the communication that delegation is intended to be used for. Whereas NSNotificationCenter fits the need for one instance to broadcast a message intended for more than one listening instance, delegation fits the scenario where an instance only needs to send a message to a single listener (the delegate).
Customization
Another common usage for delegation is to provide a delegate instance the opportunity to customize certain aspects of the delegating instance’s internal state. Once again, clues from a few of Apple’s APIs shed some light on this usage scenario. Let’s look at UITableViewDelegate first:
- tableView(_:heightForRowAtIndexPath:)
- tableView(_:editActionsForRowAtIndexPath:)
- tableView(_:indentationLevelForRowAtIndexPath:)
- tableView(_:shouldHighlightRowAtIndexPath:)
These are all customization-points that a UITableView allows its delegate to have a say in. Some of the methods are so important that the table view can’t display itself unless it gets this information from its delegate. The point here is that the table view is shifting responsibility for the implementation of that logic off to its delegate, allowing for greater controlled flexibility and customization.
Wrapping up
With delegation being such a heavily utilized strategy for organizing an iOS application’s logic, understanding what it is becomes key concern. In this article we unpacked the terms “design pattern” and “delegation” to get a grasp of why those words were chosen to describe the strategy. Finally, we looked at how the delegation pattern is used in practice, observing that two common use-cases for delegation: class-to-class communication and customization.
더심화된내용) https://www.andrewcbancroft.com/2015/04/08/how-delegation-works-a-swift-developer-guide/