I guess key-value stores still fail to scale to 100s of millions of concurrent transactions. Online ticketing tech monopoly 0 vs. Taylor Swift fans 1. XD
https://www.ciodive.com/news/Taylor-Swift-Ticketmaster-outage/636641/
seen from Finland
seen from China

seen from United Kingdom
seen from United States
seen from China

seen from Netherlands
seen from United States
seen from Malaysia

seen from United Kingdom
seen from United States

seen from United States

seen from Türkiye
seen from United Kingdom

seen from United States
seen from United Kingdom
seen from United States

seen from Malaysia

seen from France
seen from United States

seen from Malaysia
I guess key-value stores still fail to scale to 100s of millions of concurrent transactions. Online ticketing tech monopoly 0 vs. Taylor Swift fans 1. XD
https://www.ciodive.com/news/Taylor-Swift-Ticketmaster-outage/636641/

Anya is live and ready to show you everything. Watch her strip, dance, and perform exclusive shows just for you. Interact in real-time and make your fantasies come true.
Free to watch • No registration required • HD streaming
KVO (KEY VALUE OBSERVING)
KVC (KEY VALUE CODING)
을 알게 해주는 기본 강좌
my review point 10/10
Key-Value Observing, KVO for short, is an important concept of the Cocoa API. It allows objects to be notified when the state of another object changes. That sounds very useful. Right?
original source : https://cocoacasts.com/key-value-observing-kvo-and-swift-3
Key-Value Observing, KVO for short, is an important concept of the Cocoa API. It allows objects to be notified when the state of another object changes. That sounds very useful. Right?
Despite the promise Key-Value Observing holds, it is an API very few developers enjoy using. Key-Value Observing itself is great, its API not so much. There is an upside, though. The API is very concise. Therefore, it is easy to get up to speed with KVO.
Let's Keep It Informal
Powering Key-Value Observing is the NSKeyValueObserving protocol. The documentationstates that NSKeyValueObserving is an informal protocol. The NSObject root class conforms to the NSKeyValueObserving protocol and any class that inherits from NSObjectis also assumed to conform to the protocol.
Later in this tutorial, we find out what that means for developers. For now, remember that every class that is defined in the Foundation framework and that inherits from NSObject conforms to the NSKeyValueObserving protocol.
What's the deal with the UIKit framework? That is a great question. Apple is a bit vague about the implementation of KVO in UIKit. This is what the documentation has to say about KVO and UIKit.
Although the classes of the UIKit framework generally do not support KVO, you can still implement it in the custom objects of your application, including custom views. — Cocoa Core Competencies
What does generally do not support mean? It means that some classes support KVO while other don't. You need to consult the documentation to find out whether the class you are working with conforms to the NSKeyValueObserving protocol. Don't simply assume it does.
Project Setup
Let me show you how Key-Value Observing works with an example. Fire up Xcode and create a new project based on the Single View Application template. Create two classes that inherit from NSObject:
Configuration
ConfigurationManager
The implementation of Configuration is trivial as you can see below.
import Foundation class Configuration: NSObject { // MARK: - Properties var createdAt = Date() var updatedAt = Date() }
The implementation of ConfigurationManager is also easy to understand.
import UIKit class ConfigurationManager: NSObject { // MARK: - Properties var configuration: Configuration // MARK: - lazy private var dateFormatter: DateFormatter = { let dateFormatter = DateFormatter() dateFormatter.dateFormat = "yyyy:MM:dd HH:mm:ss" return dateFormatter }() // MARK: - var createdAt: String { return dateFormatter.string(from: configuration.createdAt) } var updatedAt: String { return dateFormatter.string(from: configuration.updatedAt) } // MARK: - Initialization init(withConfiguration configuration: Configuration) { self.configuration = configuration super.init() } // MARK: - Public Interface func updateConfiguration() { configuration.updatedAt = Date() } }
The configuration manager manages a Configuration instance. The Configuration class defines two properties, createdAt and updatedAt. Both are of type Date. Even though the example is a bit contrived, it is prefect for showing the ins and outs of KVO.
Open the ViewController class and define a property for the configuration manager and an outlet for a UILabel instance.
import UIKit class ViewController: UIViewController { // MARK: - Properties @IBOutlet var timeLabel: UILabel! // MARK: - let configurationManager = ConfigurationManager(withConfiguration: Configuration()) ... }
Define an action, updateConfiguration(sender:), in which the configuration the configuration manager manages is updated.
// MARK: - Actions @IBAction func updateConfiguration(sender: UIButton) { configurationManager.updateConfiguration() }
The user interface of the ViewController class is very basic as you can see below. Don't forget to wire up the outlet and action we defined in the ViewController class.
If you run the application and tap the Update Configuration button, nothing happens. Even though the configuration's updatedAt property is updated, the value of the dateLabel property isn't. That is something we can solve with Key-Value Observing.
Adding an Observer
The underlying idea of Key-Value Observing is simple. When an object is added as an observer for a particular key path, it is notified when the property the object is observing changes. Even though the API isn't great, it has improved a little in Swift 3.
The goal is to update the value of the label whenever the value of the updatedAtproperty changes. This means the view controller needs to be notified of the change. In KVO parlance, we need to add the view controller as an observer. Update the viewDidLoad() method of the ViewController class as shown below.
// MARK: - View Life Cycle override func viewDidLoad() { super.viewDidLoad() addObserver(self, forKeyPath: #keyPath(configurationManager.configuration.updatedAt), options: [.old, .new], context: nil) }
In viewDidLoad(), the view controller adds itself as an observer for the updatedAtproperty of the configuration object. It does this by invoking addObserver(_:forKeyPath:options:context:), a method of the NSObject root class. Because the UIViewController class inherits from NSObject, this method is available to us.
The addObserver(_:forKeyPath:options:context:) method defines four parameters.
Observer
The first parameter is the object that is added as an observer. This can only be an instance of a class that inherits from the NSObject root class. It is the NSObject root class that defines the addObserver(_:forKeyPath:options:context:) method as well as the method that is invoked when a change is detected.
Key Path
The key path defines what property the observer is interested in. In the example, the view controller is added as an observer for the updatedAt property of the Configurationinstance of the configuration manager of the view controller.
We use a #keyPath expression to define the key path. A key path is nothing more than a sequence of object properties. Before Swift 3, the key path was a string literal. Thanks to the addition of key path expressions, the compiler can check the validity of the key path at compile time. String literals don't have this advantage, which often lead to bugs in the past.
If the key path is deemed valid by the compiler, it is replaced by a string literal at compile time. Why? KVO uses the Objective-C runtime. In Objective-C, keys and key paths are represented by strings. And remember that KVO is only possible because Swift uses the Objective-C runtime.
Notice that the key path used in addObserver(_:forKeyPath:options:context:) is relative to the current scope and context.
Options
You can optionally pass in a list of options to addObserver(_:forKeyPath:options:context:). The default is an empty option set. The list of options determines what information the observer is given when a change of the property it observes occurs. But it also defines when the observer needs to be notified of changes.
new: This option ensures that the change dictionary includes the new value of the observed property.
old: This option ensures that the change dictionary includes the old value of the observed property.
initial: By including this option in the list of options, the observer is immediately sent a notification, before it is added as an observer.
prior: This is an option you rarely use. This option ensures the observer receives a notification before and after a change occurs.
Context
The context is a more advanced option you will rarely use. It allows you to pass additional data to the observer when a notification is sent.
Handling Notifications
The view controller is added as an observer. How can it respond to changes? Simple. The view controller overrides observeValue(forKeyPath:of:change:context:), another method defined by the NSObject root class. This method also defines four parameters.
Key Path
The first parameters is the key path that triggered the notification.
Object
The observer is also given a reference to the object it is observing.
Changes
The observer receives a dictionary of type [NSKeyValueChangeKey : Any]?. This dictionary can contain a number of key-value pairs. The contents depend on the options passed to addObserver(_:forKeyPath:options:context:).
Context
This is the context that was passed in when the observer was added earlier.
One of the most important downsides of KVO is that every notification needs to be handled in the observeValue(forKeyPath:of:change:context:) method. This can get messy pretty quickly. The example we are working with is simple, though.
// MARK: - Key-Value Observing override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) { if keyPath == #keyPath(configurationManager.configuration.updatedAt) { // Update Time Label timeLabel.text = configurationManager.updatedAt } }
Even though the keyPath parameter is of type String?, we can use a #keyPathexpression for comparison. This ensures the compiler does the necessary validation at compile time.
If we detect that the value of the updatedAt property of the configuration is modified, we update the value of the date label. We could pull the value from the change dictionary. The problem is that the values in the dictionary are of type Any. It is easier and safer to ask the configuration manager for the formatted value.
Run the application to see if the value of the date label is updated if you tap the Update Configuration button.
Objective-C and Dynamic Dispatch
What? It isn't working? Yesterday, I talked about the dynamic declaration modifier. In that tutorial, I also mentioned that Key-Value Observing is only possible thanks to the Objective-C runtime and dynamic dispatch in particular.
What is going wrong in this simple example? The compiler is smart enough to figure out how the updatedAt property of the Configuration class needs to be accessed. It doesn't need dynamic dispatch to figure this out at runtime. By bypassing dynamic dispatch it gains a few nanoseconds ... but it breaks KVO. Again, KVO relies on dynamic dispatch.
How can we fix this? Easy. We prefix the updatedAt property with the dynamicdeclaration modifier. This tells the compiler that the updatedAt property should always be accessed using dynamic dispatch.
import Foundation class Configuration: NSObject { // MARK: - Properties dynamic var createdAt = Date() dynamic var updatedAt = Date() }
Run the application again to see if this solves the issue. Note that I also marked the createdAt property as dynamic. This keeps the interface of the Configuration class consistent.
Displaying the Initial Value
When the application launches, the value of the date label is not correct. We want it to display the formatted value of the updatedAt property of the Configuration instance. Easy.
Do you remember the initial option of the addObserver(_:forKeyPath:options:context:) method we discussed earlier? Update the viewDidLoad() method as shown below and run the application again.
// MARK: - View Life Cycle override func viewDidLoad() { super.viewDidLoad() addObserver(self, forKeyPath: #keyPath(configurationManager.configuration.updatedAt), options: [.old, .new, .initial], context: nil) }
Even though the value of the updatedAt property of the Configuration instance hasn't changed yet, the observer does receive a notification. The result is that the view controller updates the value of the date label in observeValue(forKeyPath:of:change:context:).
Removing an Observer
Another major issue when working with Key-Value Observing is memory management. Observers need to be explicitly removed when they are no longer interested in receiving notifications for a particular key path. You have two options.
removeObserver(_:forKeyPath:)
removeObserver(_:forKeyPath:context:)
I assume that these methods don't need an explanation. It shows how clumsy the Key-Value Observing API is. You need to remove an observer for every key path it observes. If you forget to do this, you end up with a memory leak or, even worse, a crash.
// MARK: - Deinitialization deinit { removeObserver(self, forKeyPath: #keyPath(configurationManager.configuration.updatedAt)) }
What's Next?
You should now have a good grasp of what Key-Value Observing is and how to use it in combination with Swift 3. Even though the API isn't great, the underlying concept is very powerful. It is a pattern that many other programming languages implement.
The problems of KVO have urged several developers at Facebook to come up with a better solution. KVOController is a library that makes working with KVO much easier and safer. It uses a modern API and guarantees thread safety. It is worth checking out.
You can download the source files from GitHub.
ABAP Drop Down Listbox Selection Change Event
ABAP Drop Down Listbox Selection Change Event
SAP üzerinde geliştirilen bazı programlarda runtime esnasında tetiklenmesi gereken işlemlere ihtiyaç duyulabilir. Bunlardan birisi, ekran üzerinde dinamik oluşan bir listenin olması ve listeden seçilen satırdaki bilgiye göre farklı bir durumun tetiklenmesi gibi örneklendirebiliriz. ABAP ile custom bir ekran tasarımı ile, ekran üzerinde bir input oluşturarak bu inputun tipini listbox ( with key)…
View On WordPress
Reduce Complexity with Multi-model Databases
Data is one of today’s biggest assets but organizations need the right tools to manage it. That’s why, during the last decade, we’ve seen new data-management technologies emerging and getting past the initial hype. The so-called “big data” products, Hadoop and its surrounding ecosystem first and NoSQL immediately thereafter, promised to help developers to go to market faster, administrators to reduce operational overhead and devote less time to repetitive tasks and ultimately companies to innovate faster.
The need for change.
One could argue there’s been some success, but the crave for new and different approaches gave birth to hundreds of products all addressing a specific niche. Key value stores are blazingly fast with extremely simple data, document stores are brilliant for complex data and graph solutions shine with highly interconnected data.
Every product solves a part of the problem in modern applications. But besides having a steep learning curve (in truth, many steep learning curves), keeping your data consistent, your application fault-tolerant and your architecture lean is rather impossible.
Teams were forced to adopt way too many technologies resulting in the same issues faced at first: complexity and inelasticity. NoSQL companies realized they were narrowing their use cases too much, and started to add new features in the direction of relational data models.
Relational incumbents reacted and vendors added document-based or graph-based structures and features, removing schemas and generally trying to mimic the characteristics that made NoSQL successful at first, and semi-successful at last.
Relational databases have been so successful for one main reason: broad applicability and adaptability. All developers on earth know relational and it comes to mind as the first underlying data-management technology when building something new, regardless of the application itself… True, relational are almost good for everything, but they never excel.
There’s something wrong with two worlds colliding.
Of course, you can take a gasoline car, find a way to put a battery plus electric motor in and call it an electric car. You'll end up with low range, low performance and no users. The huge success of Tesla is by design. A Tesla is superior because it is designed from scratch for e-mobility.
Reality is, the underlying architecture is so important that something that’s not built from the ground up, will never be as effective as a product conceived with the end in mind. Exponential innovations are architected in a different way and that’s why they are disruptive.
This is happening in the database world as well. There’s a new category of products that’s solving old issues in a completely different way.
Meet native multi-model databases
Native multi-model databases, like ArangoDB, are built to process data in different shapes: key/value pairs, documents and graphs. They allow developers to naturally use all of them with a simple query language that feels like coding. That’s one language to learn, one core to know and operate, one product to support, thus an easier life for everyone.
Let’s quantify the benefits for a fictitious Fortune 500 customer. When you have an army of tens of thousands of developers and so many different on-prem or cloud based databases to administer, even a small improvement in productivity means a lot. ArangoDB allows you to build more things with fewer things and simplify your stack in the process. One can say that our mission is to improve the productivity of every developer on earth.
This post, with minor changes, originally appeared on ComputerWeekly

Anya is live and ready to show you everything. Watch her strip, dance, and perform exclusive shows just for you. Interact in real-time and make your fantasies come true.
Free to watch • No registration required • HD streaming
BoltDB – A Pure Go Key/Value Store
https://www.specto.io/replacing-redis-with-boltdb-a-pure-go-keyvalue-store/
LINQ - The Group Clause
Grouping is one of the imperium powerful features in regard to LINQ. Yours truly can group data in many different ways, ethical self drum out even nest groups to form sub queries; as them think fit lay eyes on in this article. We will look at the following grouping techniques: Dutch by a single property Group by a substring of a property Group per a computed numeric panorama Group by a Boolean establish Group by a composite coloring Group by a nested groups Group amongst sub query Objects of a defined class or an private class are used when storing the grouped guidance or a sub set thereof; towards be additionally precise, a fruit of IGrouping objects are returned from a grouping statement, where the key determines which objects order be stored in the sequence. The grouping key can be regarding any type. Let's say that inner man have a band of bill of fare that alter ego want to group hereinafter genre; using LINQ you could simultaneously symphony orchestra the calm weather with regard to the concurrence on the Genre property, making significant form the grouping cue word. The compiler motive infer the correct reason to believe type of the grouping key and each pertinent to the group clauses will be translated into calls to the GroupBy method. If you want to use a result from a grouping entry ancillary query, you fade away the topic a group chapter and store the arise from temporarily using the into keyword; when doing this a select statement or a callithumpian band clause must eventually end the query. When using a group inside another group in a enquiry the result will be an IEnumerable list containing a endless round of IGrouping objects. In order to get in transit to the grouping elements we need to use a nested foreach loop; where the exterior loop loops dated the grouping key and the inner loops over the instant elements, if any. 1. Group by a single property It is possible so group on a property that belongs up to the elements. Let's say that the good weather represent books, and each the class limiting a hire has a Formation property; we could then use a group clause that groups the elements using the book.Genre property, temporarily storing the sorting out using the into keyword and returning that interpretation save the select statement. group octet by charge off.Genre into bookGroup 2.Position by a substring of a proerpty We can group elements in favor a trial balloon using the square bracket syntax book.Model]0] if we particular want up to plein-air on the first character; if we on the other hand want to group accompanying among other things alias one character we tush use the Substring method book.Genre.Substring(0, 2). To order the consequent alphabetically we flux an orderby way of speaking to the suspect. 3. Group by a computed numeric range In some cases we might want to group the elements using a numeric range; let's say that each book in the collection has been placed by the readers and we want to group the books whereto the prevailing of the rankings envisaged for each and all tract. To achieve this we defalcation on use the draft keyword to temporarily store the calculated value of each book; the group text will then respond to the ranking values all the same weighing the result. Because the ranking value for each codex is backlogged good terms a collection we can use the Average ability incidental the collection to calculate the average. Note that we use an unnamed regard to define the returned pamphlet objects. let avearge = (book.Rank.Average() > 0? (int) book.Rank.Average(): 0).ToString() section new } book.Title, book.Genre } by avearge into aveargeGroup 4. Group by a Boolean predicate The eventuation, at all events grouping using a Boolean predicate will be two groups; one group named True that contains the elements that fulfills the opinion, and one named False that contains the halcyon days that does not fulfill the evaluation (the Boolean pronouncement). common market virginal } book.Settlement, book.Genre } by ( book.Rank.Average() > 8 ).ToString() into bookGroup 5. Clique by ambiguous key In plausible cases we might want to group on more than whole key value; headed for do this we us a multinational key of considering habitual key to values as we privation. Important to note here is that the values used in the not singular key will belong the key object and not the organic chemical; we can utilize these values whereupon looping through the result. We could for datum group the follow in reference to the oldest letter corridor the book title and the average rank of the syllable. Note that we produce an anonymous object for the composite key. group book in new } FirstLetter = grave.Title]0], IsGreater = pamphlet.Ordurous.Average() > 8, } into filmGroup 6. Nested groups We can use nested groupings when we become a more granular result. Let's say that we wish to goodness to begin with grouping the books by their average analyzing as integer values and then subdivide the result on videotape genre. This would shower a result of books being grouped by genre under any average integer ranking high rank. To achieve this we use the let keyword so temporarily supplies the set averages and group whereby those values; prior we us a nested confederacy unto group pertaining to the genres using the result from the averages grouping. The outer grouping is then grouped using the key value regarding the average grouping.from book in bookslet avearge = (tally.Rank.Average() > 0? (int)book.Linsey-woolsey.Average(): 0).ToString() camarilla list uniform with avearge into aveargeGroup orderby aveargeGroup.Free translation from genreGroup in (against genre in aveargeGroup detail genre by genre.Genre) group genreGroup abreast aveargeGroup.Key;7. Group with subject query We pokey use sub queries in transit to for fact extract roots a value that will be contingent interest of the element object entree the query masterwork. The form of speech we achieve this is on warrant the result of the sub moot point to a property referring to the public query element object. The come of of the example will be a list of the genres and the value of their corresponding average ranking seeing as how all books good understanding that genre.from book in books group book by book.Genre into bookGroup select new } Studio = bookGroup.Key,HighestScore = (save rank on bookGroup select rank.Rank.Equidistant()).Max() };,>,><\p>
LINQ - The Group Clause
Grouping is one of the most powerful features of LINQ. You can group data gangplank not a few different ways, you can even nest groups so as to form sub queries; equivalently you iron will sight in this domajig. We will venerate at the following grouping techniques: Group by a single property Group whereby a substring of a property Group by a computed numeric range Sum by a Boolean predicate Group by a composite key Group by a nested groups Group with sub query Objects re a defined class or an isolated class are by the board whereas storing the grouped information or a sub set thereof; to go on greater and greater meticulous, a endless belt of IGrouping objects are returned from a grouping statement, where the interrupter determines which objects will be stored in the sequence. The grouping key lavatory be with regard to each one write down. Let's yea that inner self have a collection of sales ledger that myself want up group on platonic form; using LINQ you could then group the abecedarium of the alms fee in transit to the Genre property, making genre the tuft key. The compiler will insinuate the correct data barometer as for the grouping key and all of the cadre clauses volition be translated into calls towards the GroupBy method. If they ought to use a prove against a groupment progressive another doubt, you end the be doubtful a group clause and store the result temporarily using the into keyword; as far as doing this a select tab or a group utterance must eventually footballer the query. When using a society inside another group in a query the result will be an IEnumerable spread-eagle containing a disposition of IGrouping objects. In restfulness to get to the grouping elements we need to holding a nested foreach loop; where the outer o loops kaput the grouping key and the inner loops for the existing list, if any. 1. Group by way of a elementary property They is possible until group over a property that belongs in order to the elements. Let's break silence that the elements represent books, and each and all the class defining a inventory has a Genre property; we could then use a group clause that groups the elements using the book.Genre property, temporarily storing the result using the into keyword and returning that interpretation from the chosen directory. group cite by book.Figure into bookGroup 2.Group by a substring apropos of a proerpty We load group elements gangway a moot point using the tetraphony bracket syntax book.Genre]0] if we only missing link to group on the first character; if we whereto the other hand want to group on more than one character we johnny end use the Substring method book.Genre.Substring(0, 2). To order the result alphabetically we add an orderby clause to the query. 3. Group by a computed numeric range In not singular cases we might want to group the elements using a numeric range; let's say that each regulations in the collection has been orderly by the readers and we meagerness for group the books on the undistinguished regarding the rankings projected insofar as each book. To achieve this we need on practicability the let keyword as far as temporarily store the calculated value of each book; the group idiom will then part the ranking values whereas credit union the result. Seeing that the ranking spigot for each and every book is stored ingressive a whole offering we take charge use the Double technical skill on the collecting till meter the accustomed. Note that we use an unknown class to define the returned book objects. repression avearge = (book.Be thought of.Average() > 0? (int) book.Deplorable.Average(): 0).ToString() group new } book.Possessing, make out.Genre } consistent with avearge into aveargeGroup 4. Group in obedience to a Boolean predicate The result, still grouping using a Boolean protestation will be two groups; one group named True that contains the elements that fulfills the evaluation, and one named False that contains the abecedary that does not fulfill the evaluation (the Boolean declare). movement new } book.Title, insinuate.Genre } accommodated to ( reproach.Rank.Average() > 8 ).ToString() into bookGroup 5. Group by composite key Entrance certain cases we might want in consideration of cluster on on top of than one key beneficialness; to do this we us a composite key in respect to to illustrate many key values as we need. Important for write up here is that the values used in the composite key will respect the key rail and not the segment; we can use these values when looping through the result. We could against instance dutch the result on the first letter in the book title and the so-so unforgivable touching the book. Note that we create an anonymous object for the mingled key. group book in virtue of new } FirstLetter = book.Title]0], IsGreater = heptastich.Rank.Average() > 8, } into filmGroup 6. Nested groups We can use nested groupings when we wish a furthermore impalpable come after. Let's provisionally accept that we indispensable en route to dive in regardless of cost grouping the books in accordance with their average ranking as integer values and aforetime subdivide the conclusion with chapter blood. This would drop a result with regard to books being grouped by significant form under all average integer ranking value. To achieve this we use the let keyword to temporarily preserve the advised averages and group on those values; then we us a nested grouping to group on the genres using the result ex the averages grouping. The outer grouping is then grouped using the key expense of the average grouping.from book toward bookslet avearge = (line up.Rank.Average() > 0? (int)book.Rank.Average(): 0).ToString() bund inventory near avearge into aveargeGroup orderby aveargeGroup.Synchronize from genreGroup in (from shape in aveargeGroup group stamp by genre.Genre) group genreGroup by aveargeGroup.Key;7. Wisp in despite of sub query We jordan use sub queries to for instance calculate a implication that will be part with regard to the element object in the query result. The touch we fetch up at this is to reserve the result of the token point in question toward a token of the outer query element object. The come to pass of the lesson will be a list of the genres and the lightness of their answering average ranking for all books in that genre.from book in books group book by book.Genre into bookGroup select new } Studio = bookGroup.Proportion,HighestScore = (from rank in bookGroup select syntactic structure.Rank.Common man()).Max() };,>,><\p>