#defne introduction

[everhaunts]

DEFNE KARAHAN // visitor

“dear reader, burn all the files, desert all your past lives. and if you don't recognize yourself, that means you did it right." – dear reader by taylor swift

(afra saraçoğlu) [THE WANDERER]. Please welcome [DEFNE KARAHAN (SHE/HER)] to Huntsville, WV. They are an [27]-year-old [VISITOR] who lives in [TOWN]. You may see them around working as a [UNEMPLOYED]. Poor unfortunate soul. We’ll see if they survive.

name: defne karahan face claim: afra saraçoğlu pronouns & gender: she/her & cis woman age: 27 height: five foot five hair color: brown eye color: green birthdate: july 13th zodiac sign: cancer orientation: bisexual, biromantic

hometown: safranbolu, turkey current residence: huntsville, west virginia (a few months) occupation: unemployed

moral alignment: true neutral vice & virtue: envy & diligence hogwarts house: gryffindor element: water enneagram: 5w6? mbti: INTJ character inspo(s): thea queen (arrow), hayley marshall (the originals), mona vanderwaal (pretty little liars), raven reyes (the 100), elizabeth keen (the blacklist) traits: cautious, independent, reserved, stubborn, resourceful, empathetic languages: turkish, arabic, english

“i remember years ago, someone told me I should take caution when it comes to love, i did.” – impossible by shontelle

BIOGRAPHY (tw death mention, child birth death mention, alcoholism)

A town in Turkey was where Defne was born, but her mother passed shortly after giving birth and so she was raised by her father.

Her father wasn’t someone who was necessarily fit to raise a child, and Defne grew up being used to him drinking a lot, picking fights with people, getting fired from jobs multiple times.

She gradually became the caretaker of the house, and of him.

He ended up passing away and Defne was left having to navigate life alone even though she was barely out of her teenage years.

Despite everything, that had still been her father and so his passing effected her. So she latched on to a guy who was her now ex-boyfriend.

He wasn't the best influence, though they were together for a few years. But Defne finally broke things off, realizing she needed to focus more on herself.

Doing a few odd jobs here and there, she eventually saved up enough to leave Turkey, wanting to see what else the world held. Traveled around for years before coming to the USA.

A road trip on an old bike eventually led her to West Virginia, where she was just aimlessly driving before getting to a fork in the road. She went right, landing her in Huntsville.

Defne has only been in town for a few months, still in shock over the implications that she and everyone else are apparently trapped.

She’s currently unemployed, not really sure if she wants to get a job yet since she’s still in the denial mode of being stuck in Huntsville.

(*** the bio insinuates defne was an only child but i am open to her having older siblings! so wcs maybe)

"but lately, her face seems slowly sinking, wasting, crumbling like pastries. and they scream, the worst things in life come free to us." – the a team by ed sheeran

SONG INSPOS dear reader by taylor swift the a team by ed sheeran impossible by shontelle nothing new by taylor swift & phoebe bridgers breakaway by kelly clarkson

[autismcodedz]

made this today

[einchant]

#einchant is a display of joy and sorrow , written by j .

manderly , wylla ; introduction , played by bruna marquezine .

redwyne , defne ; introduction , played by hande ercel .

targaryen , rhaegar ; introduction , played by justin hartley .

[myprogrammingsolver]

Introduction to Deep Learning Homework - 1

Question 1 In this question, we will defne tensors in PyTorch and use them to fnd the derivative of a linear function w.r.t its variables. We then fnd the mean squared error and conclude with fnding the optimum parameters of a linear model. 1.1 For the function y = f(x) = w.x + b, where w=[2,1] and b=3, fnd the partial derivates of y w.r.t the components of x (i.e.: dy/dx1 and dy/dx2) at x =…

[linkspooky]

Mirio Togata: Hero of Another Story

In honor of season 4 let’s do a Mirio Meta! One of the most interesting things about Mirio is how he’s introduced as another potential successor to All for One. From his introduction alone we are asked to compare him to Deku but he seems entirely different. Mirio is self confident, outspoken, extroverted, and has recognition from the entire school. Meanwhile Deku is constantly trying to earn hi splace, has a mumbling habit, introverted, and despite being the successor for All for One only got to the top eight in the Sports Festival, has trouble securing internships, and still does not show the same intense urge to rise to the number one spot as Bakugo does. They are even colored differently, Deku is a characterthat usually is shaded in heavily while Mirio is depicted mainly in whites. 

Mirio is so complete a character on his own, he really seems like someone who should be the protagonist instead of Deku. This is a clever bit of foiling on Horikoshi’s part. Let’s explore that under the cut. 

1. The Deku and the Cooler Deku

Mirio is introduced as someone who shares the same goal as Deku, to save as many people as possible, but is otherwise better than him in every way. A better, cooler Deku. In a way that makes you ask, why isn’t this guy the main character of the story? Unlike Deku who is continually struggling and falling short we see Mirio, and always confident optimist who never seems to break. 

This is a point of comparison the story is asking us to make ourselves, by bringing up the fact that Mirio was once going to be a sucessor for All for One too. That if All Might had not run into Midoriya that day, it could have so easily been the other way around and Mirio could have been the main character of this story. 

This also comes at a turning point for Deku when he’s starting to define who he is and what he wants to be as a hero other than blind admiration for All Might and a want to be just like him. It’s a challenge to Midoriya’s identity. He now has to defne himself, because there is somebody who closely resembles him but not only that but as a better him he makes Midoriya superfluous. The question asked by this arc is would everything have been better if Mirio inherited All for One? Why is Midoriya the protagonist of this story?

Midoriya is asked to define himself, whereas Mirio already knows who he is, and what he wants to be, which is why he’s much more confident of a character in comparison. 

By appearing as Deku’s total opposite, (defined by his self confidence where Deku is nervous and always second guessing himself) Mirio acts as a classic literary foil shining light on Deku’s character. (Quite literally because his name is Lumillion).

In literature, a foil is a character that shows qualities that are in contrast with the qualities of another character. The objective is to highlight the traits of the other character.  What we observe in literature very often is that a foil is a secondary character who contrasts with the major character to enhance the importance of the major character. [Literary Devices]

Mirio and Deku are as different as Night and Day, yet at the same time they both wish to become heroes for the exact same reason, they both feel the overpowering urge to save the people in front of them. This was the quality that All Might recognized in Deku in all people and the reason he decided to make Deku his heir, but in this arc we see this is not a quality unique to Deku. 

Mirio is closer to All Might than Deku. He even physically resmebles him more, he has blonde hair in the same style, is more physically built, and shares the same habit of always smiling. 

By presenting Deku with Mirio, the person who has far more qualifications to be the main character of this story than he is. The better Deku than Deku is. Deku is forced to reclaim this as his story. The opening narration starts out with this is my story of how I became the greatest hero. It’s not enough to just exist as the main character, Deku has to learn to take control of his life so that it can become his story. 

Because the alternative is being denied everything who he is, and all of his struggles. Deku usually has an attitude that he did not accomplish anything on his own, that he was given All for One and given support by the others around him which prevents him from standing out in the same way MIrio does, but in this instance Deku is finally fored to acknowledge his own efforts and that this is his story even if he received help along the way. 

2. Mirio is what Deku Could be as a Third Year

The reason we follow Deku instead of Mirio is because stories are about development, not just following a cool character around when they’ve already reached their goal. Mirio exists in the story to show the kind of person Deku could grow into. That is why Mirio is the main character of another story, for us his story has already been told and we only see him after he has crossed the finish line.

Mirio, like Deku burned out on his first Sports Festival and did not make it far enough to stand out as a student. The Mirio of one year ago is a lot like where Deku is now. If we had met him then, then he would have been challenged to grow the same way Deku is now.

The Mirio we see now is what Mirio dreamed about being a year ago, most likely all of his life. Unlike Deku, he’s no longer dreaming about becoming a hero, he sees himself as a hero. He’s completely self confident in that identity. 

The more we learn about Mirio though, the more we see he was not always like this. In fact he spent most of his life being a loud mouth wannabe loser, with none of the talent to back up his completely unearned confidence in himself. 

The way he’s introduced he seems to have an amazing untouchable quirk completely suited for being a hero, the same way Bakugo’s explosion quirk made him a prodigy. Until we learn he was born with a quirk he could barely control not suited for hero work at all. 

In a way the Mirio of the past resembles Deku a lot more, he was someone continually told he was not suited to be a hero, and that none of his efforts would make him equal to those who were better qualified. What Nighteye told Deku that he’s useless because he can’t produce results right now as he was, Mirio was told over and over again by other people.

Which is the ultimate inversion of his comparison with Deku, and what Deku needs to learn the most. MIrio does not think he’s strong, in fact he never once thought he was strong even after he reached the position of being the big three. Mirio is just not afraid ot be weak, and accepts his weakness over and over again in a way Deku cannot yet because he loses all self confidence when he thinks himself weak. 

True strength doesn’t come in always being strong all the time like All Might was. Mirio’s confidence comes not from becoming so strong that he doesn’t feel weak, but rather accepting that he’s weak and continually challenging himself. In a way not only is he a more developed Deku, he’s also an inverted Bakugo who is so terrified of being weak he constantly terrified and belittled Deku because he could not accept his own feelings of weakness. 

Mirio is a challenge to the idea that being strong is just training your quirk, and being the best fighter all the time. Mirio’s strength is just knowing how weak he is, and being okay with that. He’s emotionally strong in a way that a lot of heroes with strong quirks aren’t because they cannot stand the idea of being weak, or not being the strongest in any way.

Which is also, what could be Deku’s greatest strength as a hero. That he knows what it is to be weak, and struggle with his own weakness, and because of that he understands the weakness other people feel and their struggles. He can relate to them on a personal level, and help them find their strength. If Deku were to learn to stop being afraid of his own weakness because his lifelong struggle as a quirkless person is a deepy relatable thing to many of the characters in the series then he could master it in the same way Mirio has.

Because Mirio is just Deku but a little older. He’s someone who dreamed of being a hero all of his life, and struggled with it because he had a quirk not suited immediately for hero work. He’s someone who would have completely burned out and failed at being a hero if someone had not seen his potential.

He’s also living proof that hero society’s value of strong quirks that are good for defeating villains in a flashy way is so wrong, because if a good teacher had not found Mirio and taught him how to properly utilize his quirk then he would have fallen through the cracks of the education system. He shows that any quirk can be brought to its proper potential with the training.

Which is why what NIghteye says to Deku is so wrong. He says Deku never should have gotten the chance to inerhit All for One, even though he knows that Mirio was once like Deku, a useless try hard who could not do anything until he was taght to be better by Nighteye himself.

3. Mirio’s Flaw

In the end what dooms Mirio is exactly what Nighteye said would make him a better successor. Mirio shares All Might’s flaw that he will completely destroy his own body in order to save someone. Even if Mirio could climb to a similiar spot as All Might, it would be like producing a second All Might. 

This is what happens when All Might’s number one fanboy raises you as a sucessor. More seriously though, Nighteye saw what happened to All Might when he completely destroyed his body saving people and defined himself entirely by his use to others. 

Yet, Nighteye himself even after being a witness to that tragedy did nothing to correct that flaw. My Hero Academia is after all, about the failures of the previous generation. Due to Nighteye’s failure as a mentor, Mirio ends up losing absolutely everything he had gained from three years of hard work. His mentor, his quirk, his recognition as a hero.

Mirio’s strength comes from acknowledging his own weakness, and yet at the same time he suffers from the same complex as All Might. He can never cry or feel down on himself because he must always force himself to smile, even if he’s beaten half to death, or even if his mentor just died twenty four hours ago. It’s his inability to have any regard for his own feelings as he always puts the feelings of others first that led to his own self destruction, and not only did Nighteye not fix this quality, he actively encouraged it because at heart he wants to see All Might the way he was in his prime again instead of facing that All Might was a heavily flawed hero to begin with. 

The steps to Mirio Togata’s fall are all steps All Might would have taken. He ran ahead and fought the villain on his own, rather than waiting for backup and fighting as a team. He destroyed his own body to save Eri. He kept fighting Nighteye alone even after his body was broken. This was all heroic, but at the same time it was heroic at the cost of himself. It’s the same reason Deku breaks his bones, or All Might fights with half of his organs missing. 

Here we see again, Deku suffering fmor the same flaw I mentioned above. He does not want to make this his story, he wants to believe that none of this was his own effort, and he did not accomplish anything on his own because he’s using a borrowed power. That if anybody other than him had inherietd the quirk it would have been better, because Deku the walking inferiority complex is just the worst, most insignificant person on earth.

Which is why Mirio’s flat refusal is so important. Deku’s trying to make himself out to be a worthless person is just another form of running away. He needs to face that this is his own story, and that he cannot become Mirio or All Might.

He does not want to be them either, because Mirio and All Might’s complete selflessness is what destroyed both of them in the end. Deku is challenged not to become them, but to overcome their flaws and become someone even better than just All Might 2: electric boogaloo. 

[reborg-blog]

Clojure transducers from the ground-up: the essence.

This is the first part of an article dedicated to Clojure transducers. I initially wrote this article for uSwitch Labs (my former employer in 2017) but the articles were later removed. This first part illustrates the functional foundations of transducers. The second part contains practical examples of their use in real-life scenarios.

Introduction

Transducers have been introduced in Clojure 1.7 (at the end of 2014) and they never got the attention they deserved. The author of Clojure, Rich Hickey, recently stated in his A History of Clojure paper:

I think transducers are a fundamental primitive that decouples critical logic from list/sequence processing and construction, and if I had Clojure to do all over I would put them at the bottom.

Maybe because of some confusion with Reducers (a similar Clojure feature which focuses on parallelism), or because not all functions in the standard library are transducers-aware, many Clojure programmers are still reluctant to use them extensively. Transducers are still relegated to advanced scenarios, but there are compelling reasons to use them more often, for example to replace some common cases of sequential processing.

In this article I’m going to show you that transducers are essentially a functional abstraction (similar to combining object oriented patterns). They can be derived with a few refactoring moves on top of existing collection processing functions. The fact that Clojure offers them out of the box removes any excuse not to start using them today!

Same function, different implementations

map and filter are very common operation for stream oriented programming (there are many more in the Clojure standard library and the following examples apply to most of them as well). Here's a simplified version of how map and filter are implemented in Clojure:

(defn map [f coll] (when (not= '() coll) (conj (map f (rest coll)) (f (first coll))))) (defn filter [pred coll] (when (not= '() coll) (let [f (first coll) r (rest coll)] (if (pred f) (conj (filter pred r) f) (filter pred r)))))

map and filter clearly share some common traits in terms of iterating the input, building the output, the recursion mechanism and the actual "essence" of the operation:

The access mechanism to the input collection (first, rest, the empty list '() are all specific to the Clojure sequential interface).

Building the output (conj is used to put elements in the final list, but something else could be used).

The recursion mechanism is used to consume the input (note that this is a stack consuming and not tail-recursive loop).

The "essence" of the operation itself, which is the way "mapping" or "filtering" works (filter requires a conditional for example).

There are similar operations for data pipelines in other Clojure libraries. For example core.async is a library inspired by CSP (Communicating Sequential Processes) in which processes exchange information using channels. A common case for the sender is to apply transformations to the outgoing messages, including operations like map, filter and many others. Let's have a look at how they could be implemented in core.async (this is a simplified version of the now deprecated ones that appeared in the initial implementation):

(defn map [f in out] (go-loop [] (let [val ( in)] (if (nil? val) (close! out) (do (doseq [v (f val)] (>! out v)) (when-not (impl/closed? out) (recur))))))) (defn filter [pred ch] (let [out (chan)] (go-loop [] (let [val ( ch)] (if (nil? val) (close! out) (do (when (pred val) (>! out val)) (recur))))) out))

Again, there are similarities and common traits:

The access mechanism uses core.async primitives (!) to read and write to channels.

The recursion mechanism is implemented by the go-loop macro and related recur instruction.

The "essence" of the operation itself is the same as before: map consists of applying "f" to each value and filter uses a predicate on each value in a when condition.

We are going to see one last example inspired by another library: the Clojure Reactive extensions. RxClojure is a library implementing the Clojure bindings for RxJava. Reactive programming is a push-based model based on streams: events (called “observables”) are collected and routed to components "reacting" to compose behaviour. How could map or filter be implemented in this case? The following are not in RxClojure, as they are just calling into the relative Java version. But if we had to implement them in Clojure, they would probably look something like this:

(defn map [f xs] (let [op (operator* (fn [] (subscriber (fn [ v] (catch-error-value v (on-next (f v)))))))] (lift op xs))) (defn filter [pred xs] (let [op (operator* (fn [] (subscriber (fn [ v] (catch-error-value v (when (f v) (on-next v)))))))] (lift op xs)))

We start to see a pattern emerging, once again we can distinguish between:

The access mechanism uses lift to iterate through the incoming sequence "xs" in conjunction with on-next inside the operator implementation.

Building the output is not explicit as before. Events are consumed downstream without accumulating.

The recursion mechanism is implicit. Somewhere else in the code a loop is happening, but it's not exposed as part of the main API.

The "essence" of the operation is the same as before: map consists of (f v) for each value and filter uses a when condition.

Do we need to repeat variants of the same implementation over and over? Is there a better way?

Combinatorial Explosion

By looking at the three implementations of map and filter above, we learned that the essence of the operation and some form of iteration are general aspects. Making access to the input or building the output depends on the specific transport. We just looked at map and filter, but the same isolation of concerns is applicable to other sequential processing functions, for example:

mapcat, remove, take, take-while take-nth, drop, drop-while, replace partition-by, partition-all, keep, keep-indexed map-indexed, distinct, interpose, dedupe, random-sample [...]

The list above should also include any custom functions that you might need beyond what's offered by the Clojure standard library.

The dilemma is; how can we deal with the ensuing combinatorial explosion? Are we doomed to implement the same functions with slight variations for each new type of transport/collection? Could we just write map once and use it everywhere? Transducers are the solution to this problem (and much more).

An exercise in refactoring

To enable reuse of the general aspects of sequential processing, we need to isolate the "essence" of map or filter (or other functions from the list above) and provide a way to run them in a transport-independent fashion. If we succeed, we'll have a recipe to build processing pipelines that can be reused in different contexts.

It turns out that reduce, a well known operation in functional programming, is the key to achieve this goal. Is not a coincidence that Graham Hutton dedicated an entire paper on The universality and expressiveness of fold (fold is another name for reduce). reduce is very general because it encapsulates the prototypical tail-recursive loop. Have a look, for example, at the following "sum of all numbers in a list":

(defn reduce [f result coll] (if (not= '() coll) (reduce f (f result (first coll)) (rest coll)) result)) (reduce + 0 (range 10))

Here reduce accumulates the result explicitly as one of the parameters. This form of recursion is also called "iterative" and once transformed into a Clojure loop-recur, it doesn't consume the stack. The other interesting fact about reduce is that it decouples the iteration mechanism from the transformation semantic, which is part of our plan.

map and filter (as well as many other recursive algorithms) can be rewritten "reduce style". The fact that a stack-consuming algorithm can be rewritten as iterative is a well known property in theory of computation. By rewriting map and filter (and possibly other sequential functions) as iterative, we are offered the possibility to extract the "essence" of the operation:

;; refactoring step 1: iterative recursion style. (defn map [f result coll] (if (not= '() coll) (map f (f result (first coll)) (rest coll)) result)) (map (fn [result el] (conj result (inc el))) [] (range 10)) (defn filter [f result coll] (if (not= '() coll) (filter f (f result (first coll)) (rest coll)) result)) (filter (fn [result el] (if (odd? el) (conj result el) result)) [] (range 10))

"f" is now passed as part of the parameters in our new implementations. If you look carefully, the two functions map and filter are now identical (except for the name). Invoking them requires a more sophisticated "f" function taking two arguments: the result so far (also called accumulator) and the next element to process.

One big plus after this change is that the essence of filtering (or mapping), is now isolated from recursion and input iteration. It is not yet isolated from the way the output is built (conj in both cases) and the actual function (inc and odd? respectively). But let's take baby steps and do some renaming: map and filter can be renamed reduce because that's what they are now. Second, we can extract two new functions called "mapping" for map and "filtering" for filter:

;; refactoring step 2: rename and reuse. (defn reduce [f result coll] (if (not= '() coll) (reduce f (f result (first coll)) (rest coll)) result)) (defn mapping [result el] (conj result (inc el))) (reduce mapping [] (range 10)) (defn filtering [result el] (if (odd? el) (conj result el) result)) (reduce filtering [] (range 10))

reduce encapsulates the iteration and the sequential access mechanism. But there is still a problem with "mapping" and "filtering": if we wanted to use them on a core.async channel for instance, we'd need to abstract conj away (because conj doesn't work on channels). We can't modify "mapping" or "filtering" interface, because it is part of the reduce contract. But we can add a parameter "rf" (for Reducing Function) in a wrapping lambda and return another function of two parameters:

;; refactoring step 3: extract output construction parameter. (defn reduce [f result coll] (if (not= '() coll) (reduce f (f result (first coll)) (rest coll)) result)) (defn mapping [rf] (fn [result el] (rf result (inc el)))) (reduce (mapping conj) [] (range 10)) (defn filtering [rf] (fn [result el] (if (odd? el) (rf result el) result))) (reduce (filtering conj) [] (range 10))

We also need to extract inc and odd? which are just example functions and should be generically passed as parameters. Again, we don't want to alter the two arguments interface required by reduce, so we use another wrapping function and introduce the new parameter "f" (or "pred" for filter):

;; refactoring step 4: extract transforming and predicate functions. (defn mapping [f] (fn [rf] (fn [result el] (rf result (f el))))) (reduce ((mapping inc) conj) [] (range 10)) (defn filtering [pred] (fn [rf] (fn [result el] (if (pred? el) (rf result el) result)))) (reduce ((filtering odd?) conj) [] (range 10))

Finally, let's rename the relevant functions back to map and filter (because this is what they are after all):

;; refactoring step 5: final clean-up. (defn map [f] (fn [rf] (fn [result el] (rf result (f el))))) (defn filter [pred] (fn [rf] (fn [result el] (if (pred el) (rf result el) result))))

This is exactly how the single-arity versions of clojure.core/map and clojure.core/filter appear in the Clojure standard library (modulo some complexity related to multiple sequence arguments in map).

Along with the enriched versions of many sequential processing functions, Clojure 1.7 also introduced a new function called transduce that enables the use of map or filter without necessarily having to call reduce directly. This mainly improves readability:

(transduce (map inc) conj (range 10)) ;; same as: (reduce ((map inc) conj) [] (range 10))

The standard library also provides transducers awareness in other places. The new versions of sequence and into for example, remove the need for an explicit conj:

(sequence (map inc) (range 10)) (into [] (map inc) (range 10))

conj is not explicit because the reducing function can be inferred from the specific call to sequence (because we want to build a sequence) or into [] (we want to build a vector). Now that we have the basic recipe, it's time to put the new construct in practice and see how they can be used for our daily programming.

Conclusions

The article shows that transducers are built on top of a simple functional abstraction and there is nothing magic happening under the hood. Apart from the interesting refactoring exercise, transducers have deeper consequences in terms of reusability, composability and performance that we are going to explore in the second part of this article.

Clojure The Essential Reference

Did you enjoy reading this article? You might find my book Clojure: The Essential Refence also interesting! The book has an entire chapter dedicated to all the functions related to both reducers and transducers. There you can find more examples and insights.

[nadineyilmaz]

                   introduction  •  dossier  •  pinterest

GENERAL DETAILS.

full name:  nadine defne yilmaz

nickname(s):  dina

age:  thirty-one

date of birth:  september 25th

place of birth:  marmaris, turkey

current location:  claybourne, pennsylvania

ethnicity:  turkish

gender:  cis woman

pronouns:  she/her/hers

sexual orientation:  bisexual

romantic orientation:  biromantic

religion:  non-practicing muslim  

occupation:  curator at central gallery

living arrangements:  a ( most recently ) completely decorated townhome on summerset street—a three bed, 2 ½ bath home

financial status:  within the 75th percentile of earners, making an approx. 48k per year.

speaking voice and accent:  her voice bares a rather—perhaps flutey air about it–still bearing some semblance of her foreign hailing; often being the first thing people note about her.

spoken languages:  turkish, english, some conversational french.

PHYSICAL APPEARANCE, ETC.

faceclaim:  melisa pamuk

hair color and style:  dark brown, naturally waved masses typically styled in soft, brushed out curls, or bound into an updo.

complexion:  olivine and flecked with beauty marks.

eye color:  dark brown

height & weight:  five foot nine inches, one hundred thirty five pounds.

body and build:  averagely toned from her current workout regimen, feminal physique with hip dips and svelte legs.

tattoos:  a small butterfly tattoo along her spine, just below her shoulder blades.

piercings:  double lobe piercings in either ear.

clothing style:  elegant all while pertaining to her interests in remaining comfortable, nadine incorporates delicate fabrics, drapery, and woolen textures to compose her usual style. she teeters somewhere between the line of fashion forward, and vintage.

distinguishing characteristics:  her usually brooding visage—though she often equips a more approachable front when it comes to professional settings.

signature scent:  the faint scent of incense clung loosely to a collar spritzed with her usual lost cherry by tom ford.

HEALTH.

sleeping habits:  she sneaks naps when she can but between looking after her daughter and work, nadine is hardly well-rested.

eating habits:  mostly rigid and plant based, but nadine has come to appreciate the simple fineries of a double cheese burger ( no ketchup. )

sociability:  highly social. not only for work, but in a general sense—she strives to maintain her identity outside of being a working mother. though she quite likes being at home, a night out on the town or spending the evening on the beach is ritual for nadine.

body temperature:  typically hot natured, so she doesn’t mind the northern winters much—touch her thermostat and you’ll never hear the end of it.

alcohol use:  champagne in most social situations, and wine with her dinner or after a long day.

PERSONALITY.

label(s):  the atoner, the benevolent, the despondent.

positive traits:  allocentric, passionate, hardworking, understanding,  intuitive.

negative traits:  blunt, pessimistic, worrisome, assertive, pedantic.

likes:  beach days with her daughter. aged wine. red lipstick. working ( oddly enough. ) eclectic music. black coffee with a few cubes of sugar. frequenting the latest exhibits at the gallery.

dislikes:  the scent of lavender. large crowds. pork. sweltering weather.  when her work bleeds into her personal life. arguing, though she’s not above it. 

fears:  not living up to her personas standards.

habits:  straying from one end of a room to the other, or lingering in a doorway rather than seating herself. talking with her hands. tends to ramble about subjects she’s passionate about.

FAMILY, RELATIONSHIPS, ETC.

mother:  ayla yilmaz

father:  emir yilmaz

significant other:

best friend:  maddison halle ( d. 2018 )

exes:  patrick persuade ( aged 32 )  

sibling(s):  selma yilmaz ( older sister, aged 36 ), omar yilmaz   ( younger brother, aged 27 )

children:  jennifer persuade, dubbed “ jennie-bean ” ( aged 4 )

pet(s):  a stray tabby that her and jenny feed, named “ pickle, “ as insisted by her daughter & a french bulldog named stella.

[defneonenitp]

TUNNEL OF LIGHT

For introduction to fabrication class our first assignment was to make a flashlight. Feeling inspired by my experiments with light and light reflecting materials in the light art club, I decided to create a colorful flash light. 

INSPIRATION

My experiments with dichroic film and LED lights in light art club. (Video below)

Tunnels of light from Defne Onen on Vimeo.

For the shape of my flashlight, I wanted the shape of the cone to frame the light and change or limit it’s shape. I was inspired by sacred geometry and the Elements of Euclid shapes. The images below are examples, the left hand image is from geometry daily and the right hand image is from Oliver Bryne’s Elements of Euclid book.

DRAWINGS & SKETCHES

Below are my rough sketches (at the top left hand side and on the right hand side) where I was trying to figure out the shape and geometry of the whole flashlight and where the light comes through, where the LED will be placed etc.

 On the bottom left hand corner (separated with a border) are my more evolved sketches where I was thinking about where to place the dial, where the light turns on and off, how the material fits and enclosures. 

PROCESS 

VERSION 1

Below is the first version of my flashlight. The base of the cone, where the LED ring would sit is a hexagon. It perfectly houses the LED ring. The hexagon shape morphs into a smaller version as the cone gets taller. The smaller hexagon alters the shape of the projection. 

Version 1 with LED ring attached. 

VERSION 2

After the LED’s on and off button and all the wiring was worked out, I added on the handle of the flashlight. The handle houses a breadboard, 9V battery and all the wiring needed. Below are images of the second version. 

FAILURES

While figuring out the wiring and how to turn the LED ring on and off, I realized my breadboard was too big and bulky to be in the actual flashlight. So after some research I decided to make the circuit out of paper circuits. Below are some images of a paper circuit with a handle to close and open it. 

The problem was that the paper circuit couldn’t handle the power the LED ring needed and because the paper was very flimsy it constantly flicker on and off. 

FINAL VERSION

Please follow the link below to see the final video: TUNNELS OF LIGHT - FLASHLIGHT from Defne Onen on Vimeo.

* To leave comments or ask questions, please click on the menu icon on the top left of the page and select the comments link.

[everhaunts]

tags

[akashs123]

SMS Firewall Market 2017 Global Research Report and Gross Margin Analysis till 2023

Market Research Future published a research report on “Global SMS Firewall Market Research Report- Forecast 2023” – Market Analysis, Scope, Stake, Progress, Trends and Forecast to 2023.

Market Synopsis of SMS Firewall Market

Market Scenario

The SMS firewall solutions helps to protect and block illegal SMS traffic with the help of Mobile Network Operators (MNOs) and SMS aggregators. It is of two types including, Application-to-person messaging and person-to-application messaging, which is showing encouraging growth these days. Application to Person SMS is offering SMS filter solution to the SMS firewall market. A2P alone is estimated to reach 31% of the total annual messaging traffic in 2017.

The SMS firewall has the network-based and content-based security solution that enables the operator to protect the subscribers and enterprise customers against the SMS threat. The study indicates that the SMS firewall market has firewall and filtering solutions that proactively detect, filter, and secure illicit incoming SMS traffic solutions is provided by vendors and companies.  They also provide benefits that reduces operational costs and enhanced customer experience.

The global The SMS firewall market is expected to grow at USD ~$3.31 Billion by 2023, at ~10.5% of CAGR between 2017 and 2023.

Get Sample of Report @ https://www.marketresearchfuture.com/sample_request/3277

Key Players

The prominent players in the SMS firewall Market are: SAP SE (Germany), AMD Telecom S.A. (Greece),  Tata Communications Limited (India), Twilio Inc. (US), Anam Technologies Ltd. (Ireland), Cloudmark, Inc. (US), Global Wavenet Limited (Australia), NetNumber, Inc. (US), NewNet Communication Technologies (US) and Defne Telecommunication A.S. (Turkey) among others

Study Objectives of Global SMS Firewall:

To provide detailed analysis of the market structure along with forecast of the various segments and sub-segments of the global SMS Firewall market.

To provide insights about factors affecting the market growth.

To analyze the global SMS Firewall market based porter’s five force analysis etc.

To provide historical and forecast revenue of the market segments and sub-segments with respect to four main geographies and their countries- North America, Europe, Asia, and Rest of the World (ROW).

To provide country level analysis of the market with respect to the current market size and future prospective.

To provide country level analysis of the market for segment by Components, Type, Grid, Power Source and Geography.

To provide strategic profiling of key players in the market, comprehensively analyzing their core competencies, and drawing a competitive landscape for the market.

To track and analyze competitive developments such as joint ventures, strategic alliances, mergers and acquisitions, new product developments, and research and developments in the SMS Firewall Market.

Segments:

The global SMS firewall market has been segmented on the basis of SMS type, service, deployment, organizations, end users and region.

SMS firewall Market by SMS type:        

Application to Person (A2P) messaging

Person to Application (P2A) messaging

Others

SMS firewall Market by Service:

SMS

A2P SMS

SMS fraud

USSD

Send Routing Info

Signaling errors

Others

SMS firewall Market by Organizations:

Small and Medium Scale Enterprises

Large Scale Enterprises

SMS firewall Market by End-User:

Media and Entertainment

BFSI

Retail and wholesale

Telecom and IT

Manufacturing

Healthcare

Government

Industrial

Education

Healthcare and life sciences

Others

SMS firewall Market by Region:

North America

Europe

Asia Pacific (APAC)

Rest of the World (ROW)

Get Complete Report @ https://www.marketresearchfuture.com/reports/sms-firewall-market-3277

TABLE OF CONTENTS 1    MARKETINTRODUCTION       1.1    INTRODUCTION       1.2    SCOPE OF STUDY             1.2.1    RESEARCH OBJECTIVE               1.2.2    ASSUMPTIONS             1.2.3    LIMITATIONS       1.3    MARKET STRUCTURE:             1.3.1    GLOBAL SMS FIREWALL MARKET: BY SMS TYPE             1.3.2    GLOBAL SMS FIREWALL MARKET: BY SERVICES             1.3.3    GLOBAL SMS FIREWALL MARKET: BY DEPLOYMENT             1.3.4    GLOBAL SMS FIREWALL MARKET: BY ORGANIZATIONS             1.3.5    GLOBAL SMS FIREWALL MARKET: BY END USER             1.3.6    GLOBAL SMS FIREWALL MARKET: BY REGION 2    RESEARCH METHODOLOGY       2.1    RESEARCH SMS TYPE       2.2    PRIMARY RESEARCH       2.3    SECONDARY RESEARCH       2.4    FORECAST MODEL 3    MARKET DYNAMICS       3.1    INTRODUCTION       3.2    MARKET DRIVERS       3.3    MARKET CHALLENGES       3.4    MARKET OPPORTUNITIES 4    EXECUTIVE SUMMARY 5.    MARKETFACTOR ANALYSIS       5.1    PORTER’S FIVE FORCES ANALYSIS       5.2    SUPPLY CHAIN ANALYSIS 6     SMS FIREWALL  MARKET       6.1    INTRODUCTION       6.2    MARKETSTATISTICS             6.2.1        BY SMS TYPE                   6.2.1.1        APPLICATION TO PERSON MESSAGING                 6.2.1.2        PERSON TO APPLICATION MESSAGING                 6.2.1.3        OTHERS             6.2.2    BY SERVICES                 6.2.2.1.         SMS                 6.2.2.2.        A2P SMS                 6.2.2.3        SMS FRAUD                 6.2.2.4        USSD                 6.2.2.5        SEND ROUTING INFO                 6.2.2.6        SIGNALING ERRORS                 6.2.2.7        OTHERS             6.2.3    BY ORGANIZATIONS                 6.2.3.1        SMALL AND MEDIUM - SIZE ENTERPRISES (SME)                 6.2.3.2        LARGE - SIZE ENTERPRISES                         6.2.4       BY END-USER                 6.2.4.1        GOVERNMENT SECTOR                 6.2.4.2        INDUSTRIAL SECTOR                 6.2.4.3        MEDIA AND ENTERTAINMENT SECTOR                 6.2.4.4        EDUCATION                 6.2.4.5        BFSI                 6.2.4.6        HEALTHCARE                 6.2.4.7        MANUFATUREING                 6.2.4.8        OTHERS             6.2.5        BY REGION                 6.2.5.1        NORTH AMERICA                 6.2.5.2        EUROPE                 6.2.5.3        APAC                 6.2.5.4        ROW 7    COMPANY PROFILES       7.1    SAP SE (GERMANY)       7.2    AMD TELECOM S.A. (GREECE)       7.3    TATA COMMUNICATIONS LIMITED (INDIA)       7.4    NETNUMBER, INC. (US)       7.5    INFOBIP LTD. (UK)         7.6    DEFNE TELECOMMUNICATION A.S. (TURKEY)       7.7    NEWNET COMMUNICATION TECHNOLOGIES (US)       7.8    TWILIO INC. (US)       7.9    ANAM TECHNOLOGIES LTD. (IRELAND)       7.10          CLOUDMARK, INC. (US)       7.11       OTHERS  

About Us:

At Market Research Future (MRFR), we enable our customers to unravel the complexity of various industries through our Cooked Research Report (CRR), Half-Cooked Research Reports (HCRR), Raw Research Reports (3R), Continuous-Feed Research (CFR), and Market Research & Consulting Services.

Media Contact:

Akash Anand,

Market Research Future

Office No. 528, Amanora Chambers

Magarpatta Road, Hadapsar,

Pune - 411028

Maharashtra, India

+1 646 845 9312

Email: akash.anand@marketresearchfuture.com

[read365days]

A Mathematician's Apology by Hardy, G. H. (1967) Paperback

really, I read it for the CP Snow introduction, which is lovely, and while I enjoyed it, it's too far out of my reach. defn a one to have on the shelves though

[everhaunts]

MULTI-MUSE BLOG for huntsvillehq

WHITNEY FELL / she/they / town visitor / daily grind server (introduction & interactions) ARCHIE RUIZ / he/him / town resident / food market cashier (introduction & interactions) DEFNE KARAHAN / she/her / town visitor / unemployed (introduction & interactions)

[reborg-blog]

Exploring the memoize function

*In this article we will explore some concrete examples of the many uses and intricacies of the memoize function from the Clojure standard library. If you enjoy this article, you might very well enjoy the Clojure Standard Library book: save 37% off the book with code fccborgatti. *

memoize is a function in the Clojure standard library that adds caching capabilities to another existing function using the invocation arguments as key. When the wrapped function is invoked with the same list of arguments, the result is returned immediately from the cache without any additional computation. The effects of memoize are readily visible if we print any message from the wrapped function:

(defn- f* [a b] (println (format "Cache miss for [%s %s]" a b)) (+ a b)) (def f (memoize f*)) (f 1 2) ;; Cache miss for [1 2] ;; 3 (f 1 2) ;; 3 (f 1 3) ;; Cache miss for [1 3] ;; 4

The first invocation generates the message (the following invocations don’t), confirming that the wrapped function f* is not invoked again. Conventionally, if the wrapped function is not meant to be used directly, the star * character gets added at the end of the name, while the "memoized" version is named without one.

"Memoize" invocation contract

memoize formal specification of the function signature is as follows:

INPUT

"f" needs to be a function and is mandatory, so (fn? f) should return true. You can still provide memoize with a non-invokable object but the resulting function would be useless and throw an exception.

NOTABLE EXCEPTIONS

ClassCastException if "f" is not invokable.

OUTPUT

A new function of a variable number of arguments. memoize will eventually delegate the call to the wrapped function, so the number of arguments passed to the generated function needs to be compatible.

Examples

memoize works well for non-trivial computations accepting and returning values with a relatively small memory footprint. The following example illustrates this point. The Levenshtein distance (this Wikipedia article contains a good introduction to the Levenshtein Distance algorithm) is a simple metric to measure how different two strings are. Levenshtein distance can be used, for example, to suggest corrections for the most common spelling mistakes. The Levenshtein distance is straightforward to implement, but becomes computationally intensive for longer strings (above 10 characters long). We could use memoize to save us from computing the distance of the same pair of strings over and over again. The input (the strings arguments) and the output (a small integer) are relatively small in size, so we can cache a large amount of them without exhausting memory (assuming the list of words with which the function is invoked is a finite number that we can estimate).

To feed our example we are going to use the dictionary available on Unix systems at "/use/share/dict/words" which is a plain text list of words. If we were asked to implement an auto-correction service, it could work as follows:

The user inputs a misspelled word

The system checks the distance of the word against the words in the dictionary

The results are returned back in order of smaller distance

Although, in our example, we are just implementing the essentials, concentrating mainly the application of memoize, we are also going to pre-compute a dictionary of words starting with the initials of the word, a technique to further speed-up the Levenshtein distance calculation:

(defn levenshtein* [[c1 & rest1 :as str1] ; 1. [c2 & rest2 :as str2]] (let [len1 (count str1) len2 (count str2)] (cond (zero? len1) len2 (zero? len2) len1 :else (min (inc (levenshtein* rest1 str2)) (inc (levenshtein* str1 rest2)) (+ (if (= c1 c2) 0 1) (levenshtein* rest1 rest2)))))) (def levenshtein (memoize levenshtein*)) ; 2. (defn to-words [txt init] ; 3. (->> txt slurp clojure.string/split-lines (filter #(.startsWith % init)) (remove #(> (count %) 8)) doall)) (defn best [misp dict] ; 4. (->> dict (map #(-> [% (levenshtein misp %)])) (sort-by last) (take 3))) (defn dict [init] (to-words "/usr/share/dict/words" init)) (def dict-ac (dict "ac")) ; 5. (time (best "achive" dict-ac)) ;; "Elapsed time: 4671.226198 msecs" ; 6. (["achieve" 1] ["achime" 1] ["active" 1]) (time (best "achive" dict-ac)) ;; "Elapsed time: 0.854094 msecs" ; 7. (["achieve" 1] ["achime" 1] ["active" 1])

The Levenshtein algorithm presented here is a variation of the many available on-line. The important aspect to remember is that it grows roughly as O(n*m) where m and n are the length of the strings, which is O(n^2) in the worst scenario.

This def actually builds the wrapping function through memoize, conveniently called levenshtein without the final * that is reserved for the non-memoized version.

to-words is a helper function to prepare the dictionary filtered by the initial string. to-words is part of the "static" or "learning" phase of the algorithm, since we can prepare words by initial off-line and store them for later use.

The best function is responsible for the application of the levenshtein memoized function to the words in the dictionary. It then sorts the results with sort-by and returns the lowest distances.

The def invocation defines a filtered dictionary starting by "ac" so it doesn't need to be computed multiple times. This also prevents the time function from reporting on the time needed to read and process the file.

The first invocation to search the best matches for the misspelled word returns in almost 5 seconds.

The second invocation returns much faster.

The memoized version of the Levenshtein distance function is storing each new pair of strings as key and the returned distance as the value of an internal map. Each time the function is invoked with the same arguments, the return value is looked up inside the map. Comparing long strings seems to benefit from caching intermediate results and the elapsed confirms the theory.

This example also shows the way the memoized Levenshtein distance is "trained" before actual use. The application could pre-compute the set of dictionaries by initials (similar to the indexing happening inside a database). This technique contributes to the speed-up seen in our Levenshtein implementation, but consider that there are also other algorithms out-performing Levenshtein (See the list of metrics available on Wikipedia).

What's in a name: memoize?

There is a reason why storing arguments and return values is called "memoization" instead of just "caching". Memoization is more specific because it implies two features normally present in functional languages: pure and higher order functions.

Pure functions The wrapped function needs to be referentially transparent. If there was a way for the output to be influenced by factors other than the function arguments, then cached results could be different depending on the context. The cache would then need to be aware of the context and use it as part of the key. Memoization becomes straightforward in functional languages supporting referential transparency.

Higher order functions "Higher order" refers to the property of a function to be treated as a value. As such, the function can be stored, passed to other functions or returned. Not all languages offer higher order functions, although it is now more common to offer this feature. By describing this kind of caching as "memoization" it is implied that a function can be transparently decorated with caching capabilities. "Transparently" in this context means that the original wrapped function remains untouched.

See Also

These are other functions in the Clojure standard library that have a similar or related use to memoize.

lazy-seq creates a "thunk" (wrapper function around a value) that evaluates its content on the first access and return a cached version on following calls. When the thunks are joined together in a sequence they form a lazy sequence. Lazy sequences are comparable to a cache where the order and value of the keys is predetermined. An "evaluate once" semantic on collections could be achieved with lazy-seq. Since all Clojure sequences are lazy, you might already be using a "cached data structure" without knowing it.

atom creates a Clojure Atom, one of the possible Clojure reference types. Atoms are used by memoize to store intermediate results. Use an atom directly if the memoize implementation is too restrictive for the kind of caching you need to implement. You can, for example, look into something different than a Clojure hash-map to store items in the map, like a mutable Java map with soft-references (there are several examples of use of SoftReference for caching in Java. This is a good starting point. Keep in mind that there are already libraries like core.cache to provide common caching strategies if this is what you're looking for.

Memoize Performance and Implementation Details

O(1) steps (function generation)

O(n log n) ** steps (generated function), n number of unique keys**

O(n) ** space (generated function), n number of unique keys**

The main aspect to consider about memoize, is that it stores cached items indefinitely. Constant accumulation of new cached values will eventually exhaust memory. memoize users should pay attention to these facts when designing their solution, more specifically to the prospected distribution of keys in the cache. memoize should not be used in cases of long-running services when the amount of argument permutations is potentially infinite or not easy to predict.

We can gather some statistics about the key distribution with some changes to the original memoize function. The following memoize2 contains additional atoms to collect data cache hits, misses and total number of calls at run-time.

(defn memoize2 [f] (let [mem (atom {}) ; 1. hits (atom 0) miss (atom 0) calls (atom 0)] (fn [& args] (if (identical? :done (first args)) ; 2. (let [count-chars (reduce + (map count (flatten (keys @mem))))] {:calls @calls :hits @hits :misses @miss :count-chars count-chars :bytes (* (int (/ (+ (* count-chars 2) 45) 8)) 8)}) ; 3. (do (swap! calls inc) ; 4. (if-let [e (find @mem args)] (do (swap! hits inc) (val e)) (let [ret (apply f args) (swap! miss inc)] (swap! mem assoc args ret) ret)))))))

Along with the actual cache, additional counters are added to the initial let block.

:done is a sentinel value that can be used to extract statistics during run-time.

This is an estimate of the amount of memory necessary to store the keys given the number of chars footnote:[A good enough formula to estimate the amount of memory necessary to store strings in Java is: http://www.javamex.com/tutorials/memory/string_memory_usage.shtml].

Additional swap! operations are performed to update counters.

By accessing the additional stats at run-time, we can estimate the key-space size or the memory footprint. For example, if we run the previous Levenshtein memoize example replacing memoize with memoize2 we can extract the following results:

(def levenshtein (memoize2 levenshtein*)) (best "achive" dict-ac) (["achieve" 1] ["achime" 1] ["active" 1]) (levenshtein :done) {:calls 400, :hits 0, :misses 400 :count-chars 5168 :bytes 10376} (best "achive" dict-ac) (["achieve" 1] ["achime" 1] ["active" 1]) (levenshtein :done) {:calls 800, :hits 400, :misses 400 :count-chars 5168 :bytes 10376}

As you can see, the first time the best function is invoked it generates 400 misses, while the second time it results in all hits. We can also estimate the memory taken by the strings stored in memory which is around 10Kb.

The second aspect to consider when using memoize is the additional hash-map assoc operation and atom swap! that is added for each new key combination presented as input. The hash-map adds O(n log n) steps to add a new key while the atom could under-perform under heavy thread contention. Depending on the application requirement, memoize could be built on top of a transient data structure to avoid the performance penalty of filling the cache. Another option to consider, when possible, is "warming the cache": while the application is still not serving live traffic, the cache could be populated artificially with the most common keys.

Now that you know some of the ins and outs of using memoize, perhaps you’re more interested in learning more about the Clojure standard library. If so, download the free first chapter of Clojure Standard Library and see thia Slideshare presentation for more details.