Labour’s Sadiq Khan secures third term as Mayor of London, beating Conservative Susan Hall

Local elections results – live: Labour win in West Midlands and London as Sunak facing fresh rebellion | The Independent

Who has won in each of the local elections and what is the picture in each region?

Local election results in full: Who has declared victory in council and mayoral ballots? | The Independent

What you need to know from England&#x27;s council and mayoral polls.

Seven takeaways from the local elections - BBC News

With almost all council elections declared, Conservatives are on course to lose up to 500 seats

Key points as local election results show major Tory losses | Local elections 2024 | The Guardian

alocalo

Startups of The Year 2023 Winners: Europe

Sorting is any process of arranging items systematically in a sequence ordered by some criterion so that you can analyze it more effectively. In this article, I want to describe a common method used to sort array elements in alphabetical and numerical order. In addition to general examples, I have provided a real-life use-case example to clarify the context of sorting array values. Introduction to Sort Array Elements Sorting is the process of arranging data into a meaningful order so that you can analyze it more effectively. For example, you might want to sort the data in a column to find the string "Alex" or you might want to order sales data by calendar month so that you can produce a graph of sales performance. Sorts are most commonly in numerical or a form of alphabetical (called lexicographical) order and can be in ascending (A-Z, 0-9) or descending (Z-A, 9-0) order. Why sorting data is important? Sorting is an important algorithm in Computer Science because it can often minimize the complexity of a task or simply facilitate the later search for members of the sorted set. These algorithms have direct applications in search algorithms, database algorithms, divide-and-conquer methods, data structure algorithms, and a variety of other areas. There are different sorting algorithms for different cases but they are not in the context of this article. Note: I think it's enough for the theory so let's dive into the practical part! Sorting Array Elements Alphabetically The very straightforward and easy way to sort array elements alphabetically is to use the Array.prototype.sort method. Ascending Sort The sort method sorts the elements of an array in place and returns the sorted array. The default sort order is ascending. The sort method needs an optional compareFunction(firstEl, secondEl) parameter that defines the sort order. If omitted, the array elements are converted to strings, then sorted according to each character's Unicode code point value. Let's look at the example below: names.sort(); const names = [ 'Williams' , 'James' , 'Alex' , 'Mason' , 'Ella' , 'Jackson' ]; // Sort the "names" array console .log(names); // Output: ["Alex", "Ella", "Jackson", "James", "Mason", "Williams"] You know, there are pointers in JavaScript. You can learn more about JavaScript Pointers on our Guide. JavaScript Pointers are actually as much important as  JavaScript Scope & Scope Chain. Descending Sort You can just as easily sort the elements of an array in ascending order, but if you want to sort the elements in descending order, use the Array.prototype.reverse method after the array has been sorted as the example below: names.sort(); names.reverse(); const names = [ 'Williams' , 'James' , 'Alex' , 'Mason' , 'Ella' , 'Jackson' ]; // Sort the "names" array // Reverse the "names" array console .log(names); // Output: ["Williams", "Mason", "James", "Jackson", "Ella", "Alex"] The reverse method reverses an array in place. The first array element becomes the last, and the last array element becomes the first. Be careful, the sort method is destructive. It changes the original array. If you want to overcome this problem, make a shallow copy of the array at first and then invoke the sort method as in the example below: Warning: copyOfNames.sort(); const names = [ 'Williams' , 'James' , 'Alex' , 'Mason' , 'Ella' , 'Jackson' ]; // Make a shallow copy of the "names" array const copyOfNames = [...names]; // Sort the "copyOfNames" array console .log(names); // Output: ["Williams", "James", "Alex", "Mason", "Ella", "Jackson"] console .log(copyOfNames); // Output: ["Alex", "Ella", "Jackson", "James", "Mason", "Williams"] Node.js is important for Developers to Use in 2022. Learn more about Node.js for Developers. To Speed up your Node.js App's Performance, you should learn how to create it optimal. You can learn about speeding your Node.js App. Sorting strings with non-ASCII characters For sorting strings with non-ASCII characters, i.e. strings with accented characters (e, é, è, a, ä, etc.), strings from languages other than English, use the localeCompare method within the compareFunction parameter of sort method. ES6 is important, You should learn about ES6 Code Snippets in minutes with our Tutorial. The localeCompare method can compare those characters so they appear in the right order. }); const items = [ 'réservé' , 'communiqué' , 'café' , 'adieu' , 'éclair' ]; items.sort( function ( a, b ) { return a.localeCompare(b); console .log(items); // Output: ["adieu", "café", "communiqué", "éclair", "réservé"] The localeCompare method returns a number indicating whether a reference string comes before, or after, or is the same as the given string in sort order. Note: Sorting Array Elements Numerically To sort numbers, you can use the Array.prototype.sort method, but as long as array items are converted to strings and compared in UTF-16 code units, all you need is a simple trick. But let's once sort an array of numbers without applying that trick and see the result: numbers.sort(); const numbers = [ 9 , 1 , 80 , 100 ]; console .log(numbers); // Output: [1, 100, 80, 9] The array got sorted alphabetically, so each integer actually got coerced into a string type. Then each string was compared, which is why 80 came before 9 and 100 came before 80 — strings are compared character-by-character. Have you ever thought of using Chakra UI & What are its Benefits? If not, you can learn more about using Chakra UI in 2022. The solution to achieve a numeric sort is passing a comparison (a, b) => a - b function to the sort method as a parameter. }); const numbers = [ 9 , 1 , 80 , 100 ]; numbers.sort( function ( a, b ) { return a - b; console .log(numbers); // Output: [1, 9, 80, 100] If the compareFunction parameter is supplied to the sort method, all non-undefined array elements are sorted according to the return value of the compare function. If a and b are two elements being compared, then: If compareFunction(a, b) returns a value > 0, sort b before aIf compareFunction(a, b) returns a value ≤ 0, leave a and b in the same order So, the compare function can have something like this under the hood: } } } function compare ( a, b ) { if (a is less than b by some ordering criterion) { return - 1 ; if (a is greater than b by the ordering criterion) { return 1 ; // a must be equal to b return 0 ; Ascending Sort To sort an array numerically in ascending order, the comparison function (a, b) => a - b should return the difference between the two numbers. const numbers = [ 8 , - 2 , 10 , 100 , 19 , - 4 , - 10 ]; numbers.sort( ( a, b ) => a - b); console .log(numbers); // Output: [-10, -4, -2, 8, 10, 19, 100] The comparison function (a, b) => a - b subtracts the second item from the first, returning a negative value if the second item is bigger, a positive value if the second item is smaller, and zero if the two items are equal. Descending Sort A descending sort would just need the operators reversed, so the comparison function becomes (a, b) => b - a. const numbers = [ 8 , - 2 , 10 , 100 , 19 , - 4 , - 10 ]; numbers.sort( ( a, b ) => b - a); console .log(numbers); // Output: [100, 19, 10, 8, -2, -4, -10] Use-case Consider the following array which each element of it is an object, holding two properties of name and score: ]; const results = [ { name : 'Edward' , score : 87 }, { name : 'Williams' , score : 50 }, { name : 'Andy' , score : 45 }, { name : 'Ella' , score : 75 }, { name : 'Alex' , score : 68 }, { name : 'Mason' , score : 37 } The use-case is to sort the results array once according to the names and once according to the score in ascending orders. Give it a try and then look at the solution! Arrays of objects can be sorted by comparing the value of one of their properties. Hint: Let's do it! As mentioned above in the hint, arrays whose elements are objects can be sorted by comparing the value of one of their properties. So let's start with sorting the results array according to the score property: }); // Make a shallow copy const resultsSortedAccordingToScore = [...results]; // Sort in ascending order resultsSortedAccordingToScore.sort( function ( a, b ) { return a.score - b.score; console .log(resultsSortedAccordingToScore); /* * (6) [{…}, {…}, {…}, {…}, {…}, {…}] *   0: {name: "Mason", score: 37} *   1: {name: "Andy", score: 45} *   2: {name: "Williams", score: 50} *   3: {name: "Alex", score: 68} *   4: {name: "Ella", score: 75} *   5: {name: "Edward", score: 87} */ As you see, the resultsSortedAccordingToScore has been sorted according to the score property. You can learn about JavaScript on our Website with #1 Programming Tutorials. In the next step, let's sort the results array according to the name property: } } }); // Make a shallow copy const resultsSortedAccordingToName = [...results]; // Sort in ascending order resultsSortedAccordingToName.sort( function ( a, b ) { let nameA = a.name.toLowerCase(); let nameB = b.name.toLowerCase(); if (nameA < nameB) { return - 1 ; if (nameA > nameB) { return 1 ; // names must be equal return 0 ; console .log(resultsSortedAccordingToName); /* * (6) [{…}, {…}, {…}, {…}, {…}, {…}] *   0: {name: "Alex", score: 68} *   1: {name: "Andy", score: 45} *   2: {name: "Edward", score: 87} *   3: {name: "Ella", score: 75} *   4: {name: "Mason", score: 37} *   5: {name: "Williams", score: 50} */ As you see the output, the array has been sorted according to the name property of the results array but was a little bit tricky. In the first step, I converted all the letters of name properties to lower case letters (or upper case letters) to do a case-insensitive comparison. The Alex and alex are different strings because a and A holds different Unicode code point values. Note: Conclusion The JavaScript sort method orders the elements of an array alphabetically in ascending order by default. The sort modifies an array in place which means the method does not return a new sorted array. In order to sort an array in descending order, instantly invoke Array.prototype.reverse method after the array has been sorted. In this article, I have broken down how to sort an array in JavaScript using sort method in either ascending and descending orders, both numerically and alphabetically, and at the end, I provided a real-life use-case example for a better understanding of the subject. SUBCRIBE TO OUR NEWSLETTER TO RECIEVE EXCULSIVE CONTENT EVERY WEEK FROM THE BEST PROGRAMMING PUBLICATION FOR FREE. subscribe!

How to Sort Array Elements: An Essential Guide

This post will cover the . It will mostly be an exercise in how to specialize types, simplify the substitutions and come up with the only reasonable implementation. foundations learning Motivation The monad, or more generally the interface, solves the problem of threading the same configuration to many functions. Reader MonadReader -- Imagine this is a directorytype Config = FilePath load :: Config -> String -> IO Stringload config x = readFile (config ++ x) loadRevision :: Config -> Int -> IO StringloadRevision config x = load config ("history" ++ show x ++ ".txt") loadAll :: Config -> Int -> String -> IO (String, String)loadAll config x y = doa <- load config yb <- loadRevision config xreturn (a, b) If you look at you’ll see is not used, but is threaded through to the child functions. This is a common source of boilerplate and the reader monad attempts to ameliorate it. loadAll config So instead of threading the to each function, we can rewrite this using and the configuration will get passed implicitly. To retrieve the configuration, we call : config MonadReader ask -- Imagine this is a directorytype Config = FilePath load :: (MonadReader Config m, MonadIO m) => String -> m Stringload x = doconfig <- askliftIO $ readFile (config ++ x) loadRevision :: (MonadReader Config m, MonadIO m) => Int -> m StringloadRevision x = load ("history" ++ show x ++ ".txt") loadAll :: (MonadReader Config m, MonadIO m) => Int -> String -> m (String, String)loadAll x y = doa <- load yb <- loadRevision xreturn (a, b) If you look at the intermediate functions and we no longer have to take in and pass the config around. However the “leaf” function has gotten more complicated. We will later extend this example to make it reusable across concrete configurations and compare it to alternatives; but first some basics. loadRevision loadAll load ( (->) e), Reader, ReaderT and MonadReader When Haskellers mention the “reader monad” they could be referring to one of four related things: The instance for functions with the same first argument, which is written somewhat inscrutably as (which I think of as ). Monad ((->) e) (e ->) type Reader = ReaderT Identity The type ReaderT Anything that implements the type class. MonadReader It’s worth understanding all four of these concepts. What does a Monad for functions with the same first argument do? Remember that a is also a and an . To understand the monad for we will try to guess the implementations for the , and instances by looking at the types after substituting into the type signatures. Monad Functor Applicative ((->) e) Functor Applicative Monad ((->) e) Functor instance First the instance. Let’s write out the type of . [Functor](https://hackage.haskell.org/package/base-4.9.1.0/docs/Prelude.html#t:Functor) [fmap](https://hackage.haskell.org/package/base-4.9.1.0/docs/Prelude.html#v:fmap) Class Functor f wherefmap :: (a -> b) -> f a -> f b It is not clear from looking at this type signature, what the instance for will do. Functor ((->) e) One easy way to understand what the implementation of should be is to look at the implementation in . Another way is to infer it by writing out the specialized instance signature. This is a somewhat tedious process, but it is good practice for implementing instances and understanding how they must work. Functor base The process starts by making a substitution for the type variable introduced in the type class, in this case . f So we substitute : f = ((->) e) fmap :: (a -> b) -> (((->) e) a) -> (((->) e) b) Then we simplify fmap :: (a -> b) -> (((->) e) a) -> (((->) e) b)fmap :: (a -> b) -> ((->) e a) -> ((->) e b)fmap :: (a -> b) -> (e -> a) -> (e -> b)fmap :: (a -> b) -> (e -> a) -> e -> b I am going to relabel the variables with the following substitutions, , , and (because I already know what to look for ;)). e = a a = b b = c fmap :: (b -> c) -> (a -> b) -> a -> c And now we can see that for is compose fmap ((->) e) [.](https://hackage.haskell.org/package/base-4.9.1.0/docs/Prelude.html#v:.) fmap :: (b -> c) -> (a -> b) -> a -> cfmap f g x = f (g x) There is no other non-evil implementation for that type signature. This leads to the fun trick of trolling your coworker by writing as as in fmap . fmap fmap fmap fmap > (fmap fmap fmap) (+1) [Just 1, Just 2, Nothing][Just 2, Just 3, Nothing] Applicative instance First let’s write out . [pure](https://hackage.haskell.org/package/base-4.9.1.0/docs/Prelude.html#v:pure) pure :: a -> f a substitute f = ((->) e) pure :: a -> (((->) e) a) simplify pure :: a -> e -> a So we end up with a function that takes in an and some random other argument and returns an . This must work for all s and s and there is no way to combine unknown types. Therefore, the only thing the function can do is return back the it was given. Hence it is : a e a e a a [const](https://hackage.haskell.org/package/base-4.9.1.0/docs/Prelude.html#v:const) pure :: a -> e -> apure x _ = x Next we have or . [<*>](https://hackage.haskell.org/package/base-4.9.1.0/docs/Prelude.html#v:-60--42--62-) [ap](https://hackage.haskell.org/package/base-4.9.1.0/docs/Control-Monad.html#v:ap) (<*>) :: f (a -> b) -> f a -> f b substitute f = ((->) e) (<*>) :: (((->) e) (a -> b)) -> (((->) e) a) -> (((->) e) b) Simplify (<*>) :: ((e -> (a -> b)) -> (e -> a) -> (e -> b)(<*>) :: (e -> a -> b) -> (e -> a) -> (e -> b)(<*>) :: (e -> a -> b) -> (e -> a) -> e -> b So the takes two functions that both have as the first argument and chains them to make a new function that takes an and gives the chained output. <*> e e (<*>) :: (e -> a -> b) -> (e -> a) -> e -> bf <*> g = \e -> f e (g e) Monad instance We have already covered : it’s just , which is just . [return](https://hackage.haskell.org/package/base-4.9.1.0/docs/Control-Monad.html#v:return) pure const First, the type for bind: (>>=) :: m a -> (a -> m b) -> m b Substitute m = ((->) e) (>>=) :: (((->) e) a) -> (a -> (((->) e) b)) -> (((->) e) b) Simplify (>>=) :: (e -> a) -> (a -> (e -> b)) -> (e -> b)(>>=) :: (e -> a) -> (a -> e -> b) -> e -> b Bind is basically a flipped-around <*> (>>=) :: (e -> a) -> (a -> e -> b) -> e -> bg >>= f = flip f <*> g is more interesting. flattens a two layers of a monad to one. [join](https://hackage.haskell.org/package/base-4.9.1.0/docs/Control-Monad.html#v:join) join join :: Monad m => m (m a) -> m a Let’s substitute m = ((->) e) join :: (((->) e) (((->) e) a))) -> (((->) e) a) Simplify join :: (((->) e) ((->) e a))) -> ((->) e a)join :: ((->) e) (e -> a)) -> (e -> a)join :: (e -> (e -> a)) -> e -> ajoin :: (e -> e -> a) -> e -> a There is only really one non-evil implementation for this type signature, and it is equivalent to the following: join :: (e -> e -> a) -> e -> ajoin f x = f x x we get for free, but it is good to see how it could be implemented by hand. It’s sometimes used for creating a tuple with the same value for the first and second value. join > join (,) 1(1, 1) What is Reader? You can think of as being a around [Reader](https://hackage.haskell.org/package/transformers-0.5.4.0/docs/Control-Monad-Trans-Reader.html#t:Reader) newtype (e -> a) newtype Reader e a = Reader { runReader :: e -> a } However, these days it is defined as a specialized version of . [ReaderT](https://hackage.haskell.org/package/transformers-0.5.4.0/docs/Control-Monad-Trans-Reader.html#t:ReaderT) type Reader = ReaderT Identity For all intents and purposes, it works just like the , and instances, . There is really no reason to use it if will suffice. Functor Applicative Monad ((->) e) ((->) e) MonadReader is the general interface for reader monads. The type class is essentially what follows: [MonadReader](https://hackage.haskell.org/package/mtl-2.2.1/docs/Control-Monad-Reader-Class.html#t:MonadReader) class Monad m => MonadReader r m | m -> r whereask :: m rlocal :: (r -> r) -> m a -> m a Let’s see what the implementation for must be by substituting and : ((->) e) m = ((->) e) r = e instance MonadReader e ((->) e) whereask :: e -> eask = ? local :: (e -> e) -> (e -> a) -> e -> alocal = ? can only really be one thing: [ask](https://hackage.haskell.org/package/mtl-2.2.1/docs/Control-Monad-Reader-Class.html#v:ask) ask :: e -> eask = id is a little trickier. It is not completely determined by the type. The documentation says it takes in a function that modifies the environment and a that uses the modified environment. [local](https://hackage.haskell.org/package/mtl-2.2.1/docs/Control-Monad-Reader-Class.html#v:local) e -> e e -> a Here we go: local :: (e -> e) -> (e -> a) -> e -> alocal f action = action . f ReaderT is the transformer version of . It allows you to add the “first argument threading” capabilities of “Reader” with another . A common choice is . Our example at the beginning of the article could be rewritten with instead of but little is gained by specifying the transformer stack directly. It is more flexible to write the functions using the reader monad interface . [ReaderT](https://hackage.haskell.org/package/transformers-0.5.4.0/docs/Control-Monad-Trans-Reader.html#t:ReaderT) Reader Monad ReaderT e IO ReaderT e IO MonadReader MonadReader One advantage of using directly is that we can take advantage of a more expressive version of , mainly which has the following type: ReaderT local [withReaderT](https://hackage.haskell.org/package/mtl-2.2.1/docs/Control-Monad-Reader.html#v:withReaderT) withReaderT :: (r' -> r) -> ReaderT r m a -> ReaderT r' m a Unlike can change the type of the environment from to . local withReaderT r r' Next Up That’s all for now. In a future post I’ll discuss some enhancements and compare the Reader Monad against some alternatives. is how hackers start their afternoons. We’re a part of the family. We are now and happy to opportunities. Hacker Noon @AMI accepting submissions discuss advertising & sponsorship To learn more, , , or simply, read our about page like/message us on Facebook tweet/DM @HackerNoon. If you enjoyed this story, we recommend reading our and . Until next time, don’t take the realities of the world for granted! latest tech stories trending tech stories

The Reader Monad — Part 1

How to Write Your Own Typesafe React Router in 500 Lines

কিভাবে 500 লাইনে আপনার নিজের টাইপসেফ রিঅ্যাক্ট রাউটার লিখবেন

So schreiben Sie Ihren eigenen typsicheren React-Router in 500 Zeilen

Cómo escribir su propio enrutador Typesafe React en 500 líneas

Comment écrire votre propre routeur Typesafe React en 500 lignes

500 पंक्तियों में अपना खुद का टाइपसेफ रिएक्ट राउटर कैसे लिखें

独自のタイプセーフな React Router を 500 行で書く方法

500줄로 나만의 Typesafe React Router를 작성하는 방법

Como escrever seu próprio roteador Typesafe React em 500 linhas

Как написать свой собственный Typesafe React Router в 500 строк

Kendi Typesafe React Router'ınızı 500 Satırda Nasıl Yazabilirsiniz?

Cách viết Bộ định tuyến React Typesafe của riêng bạn trong 500 dòng

如何用 500 行代码编写自己的类型安全 React 路由器

Optimize Data Migration in MongoDB: Resharding Techniques for Speed and Scalability

মঙ্গোডিবিতে ডেটা মাইগ্রেশন অপ্টিমাইজ করুন: গতি এবং স্কেলেবিলিটির জন্য রিশার্ডিং টেকনিক

Optimieren Sie die Datenmigration in MongoDB: Resharding-Techniken für Geschwindigkeit und Skalierbarkeit

Optimice la migración de datos en MongoDB: técnicas de fragmentación para velocidad y escalabilidad

Optimiser la migration des données dans MongoDB : techniques de repartitionnement pour la vitesse et l'évolutivité

MongoDB में डेटा माइग्रेशन को ऑप्टिमाइज़ करें: स्पीड और स्केलेबिलिटी के लिए रीशेयरिंग तकनीक

MongoDB でのデータ移行の最適化: 速度とスケーラビリティのためのリシャーディング手法

MongoDB에서 데이터 마이그레이션 최적화: 속도와 확장성을 위한 리샤딩 기술

Otimize a migração de dados no MongoDB: técnicas de resharding para velocidade e escalabilidade

MongoDB'de Veri Geçişini Optimize Edin: Hız ve Ölçeklenebilirlik için Yeniden Paylaşım Teknikleri

Tối ưu hóa quá trình di chuyển dữ liệu trong MongoDB: Kỹ thuật chia lại cấu trúc cho tốc độ và khả năng mở rộng

优化 MongoDB 中的数据迁移：用于速度和可扩展性的重新分片技术

I’ve spent the last few weeks learning about compose and decided to write a post to share my notes. This post is not meant to teach you everything about Compose but rather it’ll be more like a roadmap that you can use to learn Compose or to see what you still don’t know about Compose. This article will be constantly updated as I learn new things. State hoisting State hoisting is a pattern of moving state up to make a component stateless. When applied to composables, this often means introducing two parameters to the composable. value: T – the current value to display onValueChange: (T) -> Unit – an event that requests the value to change, where T is the proposed new value CompositionLocal Tool for passing data down through the Composition implicitly. CompositionLocalProvider(LocalContentAlpha provides ContentAlpha.medium) {
  Text(...)
}
CompositionLocalProvider(LocalContentAlpha provides ContentAlpha.disabled) {
  Icon(...)
  Text(...)
} compositionLocalOf Changing the value provided during recomposition invalidates only the content that reads its current value. data class Elevations(val card: Dp = 0.dp, val default: Dp = 0.dp)
val LocalElevations = compositionLocalOf { Elevations() } // Create composition with default value

val elevations = Elevations(card = 4.dp, default = 2.dp) // Provide different value here
CompositionLocalProvider(LocalElevations provides elevations) { ... } staticCompositionLocalOf Reads of a are not tracked by Compose. Changing the value causes the entirety of the content lambda where the CompositionLocal is provided to be recomposed. staticCompositionLocalOf If the value provided to the CompositionLocal is highly unlikely to change or will never change, use to get performance benefits. staticCompositionLocalOf Keeping track of changes remember A value computed by remember will be stored in the composition tree, and only be recomputed if the keys to remember change. When adding memory to a composable, always ask yourself “will some caller reasonably want to control this?” If the answer is yes, make a parameter instead. If the answer is no, keep it as a local variable. Remember stores values in the Composition, and will forget them if the composable that called remember is removed. This means you shouldn’t rely upon remember to store important things inside of composables that add and remove children such as . LazyColumn rememberSaveable It behaves similarly to remember, but the stored value will survive the activity or process recreation using the saved instance state mechanism rememberUpdatedState In some situations you might want to capture a value in your effect that, if it changes, you do not want the effect to restart. Create a reference to this value which can be captured and updated. rememberLauncherForActivityResult val result = remember { mutableStateOf<Bitmap?>(null) }
val launcher = rememberLauncherForActivityResult(ActivityResultContracts.TakePicturePreview()) {
  result.value = it
}

Button(onClick = { launcher.launch() }) { ... }

result.value?.let { image ->
  Image(image.asImageBitmap(), null, modifier = Modifier.fillMaxWidth())
} rememberCoroutineScope In order to launch a coroutine outside of a composable, but scoped so that it will be automatically canceled once it leaves the composition is used for scoping jobs initiated by the composition. is for scoping jobs initiated by a user interaction. LaunchedEffect rememberCoroutineScope LaunchedEffect Call suspend functions safely from inside a composable. The coroutine will be cancelled if LaunchedEffect leaves the composition. If LaunchedEffect is recomposed with different keys, the existing coroutine will be cancelled and the new suspend function will be launched in a new coroutine. val currentOnTimeout by rememberUpdatedState(onTimeout)

LaunchedEffect(true) {
  delay(SplashWaitTimeMillis)
  currentOnTimeout()
} snapshotFlow Convert Compose State<T> objects into a Flow. DisposableEffect DisposableEffect is meant for side effects that need to be cleaned up after the keys change or the composable leaves the Composition. DisposableEffect(dispatcher) {
  dispatcher.addCallback(backCallback)
  onDispose {
    backCallback.remove()
  }
} derivedStateOf derivedStateOf is used when you want a Compose State that’s derived from another State. State Holder State holders always need to be in order to keep them in the Composition and not create a new one every time. It’s a good practice to create a method in the same file that does this to remove boilerplate and avoid any mistakes that might occur. remembered Layouts LazyColumn and LazyRow Don’t recycle their children like RecyclerView. It emits new Composables as you scroll through it and is still performant as emitting Composables is relatively cheap compared to instantiating Android Views. val listState = rememberLazyListState()

LazyColumn(
  contentPadding,
  verticalArrangement / horizontalArrangement = Arrangement.spacedBy
) {
  stickyHeader { Header()  } // Experimental
  items(5) { index -> Text(text = "Item: $index") } // key = ...
  item { Text(text = "Last item") }
}

LaunchedEffect(listState) {
  snapshotFlow { listState.firstVisibleItemIndex }
}

firstVisibleItemIndex
firstVisibleItemScrollOffset

scrollToItem()
animateScrollToItem() ConstraintLayout ConstraintLayout {
  val (button, text) = createRefs()

  Button(
    modifier = Modifier.constrainAs(button) {
      top.linkTo(parent.top, margin = 16.dp)
    }
  )

  Text("Text", Modifier.constrainAs(text) {
    top.linkTo(button.bottom, margin = 16.dp)
  })
}

ConstraintSet {
  val button = createRefFor("button")
  val text = createRefFor("text")

  constrain(button) { ... }
  constrain(text) { ... }
} Layout Instead of controlling how a single composable gets measured and laid out on the screen, you might have the same necessity for a group of composables. For that, you can use the Layout composable to manually control how to measure and position the layout’s children. Layout(
  modifier = modifier,
  content = content
) { measurables, constraints ->
  // Don't constrain child views further, measure them with given constraints
  val placeables = measurables.map { measurable -> measurable.measure(constraints) }

  // Set the size of the layout as big as it can
  layout(constraints.maxWidth, constraints.maxHeight) {
    var yPosition = 0

    placeables.forEach { placeable ->
      placeable.placeRelative(x = 0, y = yPosition)
      yPosition += placeable.height
    }
  }
} Intrinsic measurements Row(modifier = modifier.height(IntrinsicSize.Min)) Navigation val navController = rememberNavController()
val backstackEntry = navController.currentBackStackEntryAsState()

NavHost(navController = navController, startDestination = "profile") {
  composable(
    "profile/{userId}/?mode={mode}",
    arguments = listOf(
      navArgument("userId") { type = NavType.StringType },
      navArgument("mode") { defaultValue = "lite" },
    ),
    deepLinks = listOf(navDeepLink {
      uriPattern = "rally://$accountsName/{name}"
    })
  ) { 
    Profile(/*...*/) 
  }
  
  loginGraph()
}

fun NavGraphBuilder.loginGraph(navController: NavController) {
  navigation(startDestination = "username", route = "login") {
    composable("username") { ... }
  }
}

navController.navigate("friends") {
  popUpTo("home") { inclusive = true }
}

navController.navigate(screen.route) {
  // Pop up to the start destination of the graph to avoid building up a large stack 
  // of destinations on the back stack as users select items
  popUpTo(navController.graph.findStartDestination().id) {
    saveState = true
  }
  // Avoid multiple copies of the same destination when reselecting the same item
  launchSingleTop = true
  // Restore state when reselecting a previously selected item
  restoreState = true
} ViewModel @HiltViewModel
class ExampleViewModel @Inject constructor(
  ...
) : ViewModel() { /* ... */ }

@AndroidEntryPoint
class ExampleActivity : AppCompatActivity()

@Composable
fun ExampleScreen(
  exampleViewModel: ExampleViewModel = viewModel()
) { /* ... */ } Animation You can create an animation value by simply wrapping the changing value with the corresponding variant of composables. animate*AsState Float, Color, Dp, Size, Bounds, Offset, Rect, Int, IntOffset, and IntSize You can combine multiple transition objects with a + operator. MutableTransitionState(false).apply {
  targetState = true  // Start the animation immediately
  // isIdle, currentState
} AnimatedVisibility Content within (direct or indirect children) can use the animateEnterExit modifier to specify different animation behavior for each of them. AnimatedVisibility AnimatedContent defines how the size should animate between the initial and the target contents. SizeTransform animateContentSize Animates a size change Crossfade Animates between two layouts with a crossfade animation. Animatable Animatable is a value holder that can animate the value as it is changed via . animateTo sets the current value to the target value immediately. snapTo starts an animation that slows down from the given velocity. animateDecay val color = remember { Animatable(Color.Gray) }
LaunchedEffect(ok) { color.animateTo(if (ok) Color.Green else Color.Red) }InfiniteTransition InfiniteTransition Holds one or more child animations like Transition, but the animations start running as soon as they enter the composition and do not stop unless they are removed. Use the function. rememberInfiniteTransition Transition Transition manages one or more animations as its children and runs them simultaneously . between multiple states var currentState by remember { mutableStateOf(BoxState.Collapsed) }
val transition = updateTransition(currentState)

// Start in collapsed state and immediately animate to expanded
var currentState = remember { MutableTransitionState(BoxState.Collapsed) }
currentState.targetState = BoxState.Expanded
val transition = updateTransition(currentState)

transition.AnimatedVisibility
transition.AnimatedContent AnimationSpec spring(
  dampingRatio = Spring.DampingRatioHighBouncy,
  stiffness = Spring.StiffnessMedium
)

tween(
  durationMillis = 300,
  delayMillis = 50,
  easing = LinearOutSlowInEasing
)

// animates based on the snapshot values specified at different timestamps
keyframes {
  durationMillis = 375
  0.0f at 0 with LinearOutSlowInEasing // for 0-15 ms
  0.2f at 15 with FastOutLinearInEasing // for 15-75 ms
  0.4f at 75 // ms
  0.4f at 225 // ms
}

// runs a animation repeatedly until it reaches the specified iteration count
repeatable(
  iterations = 3,
  animation = tween(durationMillis = 300),
  repeatMode = RepeatMode.Reverse
)

// like repeatable, but it repeats for an infinite amount of iterations
infiniteRepeatable(
  animation = tween(durationMillis = 300),
  repeatMode = RepeatMode.Reverse
)

// immediately switches the value to the end value
snap(delayMillis = 50) Theming When defining colors, we name them “literally”, based on the color value, rather than “semantically” e.g. Red500 not primary. This enables us to define multiple themes e.g. another color might be considered primary in dark theme or on a differently styled screen. isSystemInDarkTheme() / MaterialTheme.colors.isLight color: Color = MaterialTheme.colors.surface, contentColor: Color = contentColorFor(color) When setting the color of any elements, prefer using a Surface to do this as it sets an appropriate content color value, be wary of direct Modifier.background calls which do not set an appropriate content color. CompositionLocal TextFieldDefaults textFieldColors outlinedTextFieldColors ProvideTextStyle So how do components set a theme typography style? Under the hood they use the composable (which itself uses a CompositionLocal) to set a “current” TextStyle. The Text composable defaults to querying this “current” style if you do not provide a concrete textStyle parameter. ProvideTextStyle Resources stringResource(R.string.congratulate, "New Year", 2021)
dimensionResource(R.dimen.padding_small)

painterResource(id = R.drawable.ic_logo)
animatedVectorResource(id = R.drawable.animated_vector)

Icon(Icons.Rounded.Menu) Fonts private val light = Font(R.font.raleway_light, FontWeight.W300)
private val regular = Font(R.font.raleway_regular, FontWeight.W400)
private val medium = Font(R.font.raleway_medium, FontWeight.W500)
private val semibold = Font(R.font.raleway_semibold, FontWeight.W600)

// Create a font family to use in TextStyles
private val craneFontFamily = FontFamily(light, regular, medium, semibold) buildAnnotatedString buildAnnotatedString {
  append("This is some unstyled text\\n")
  withStyle(SpanStyle(color = Color.Red)) {
    append("Red text\\n")
  }
  pushStringAnnotation(tag = "URL", annotation = "<https://developer.android.com>")
  withStyle(SpanStyle(fontSize = 24.sp)) {
    append("Large text")
  }
  pop()
} Generic Modifiers align
alignBy

// animateEnterExit modifier can be used for any direct or indirect children 
// of AnimatedVisibility to create a different enter/exit animation than 
// what's specified in AnimatedVisibility.
animateEnterExit(enter, exit)

border
background
clip
clipToBounds

drawBehind
drawWithCache
drawWithContent

// The draw layer can be invalidated separately from parents. 
// scaleX, scaleY, rotationXYZ, alpha, shadowElevation, shape, clip, shape
// Use with state values such as ScrollState or LazyListState
graphicsLayer

shadow
zIndex

onKeyEvent

// Creates a LayoutModifier that allows changing how the wrapped element is 
// measured and laid out.
layout

absoluteOffset
offset

fillMaxHeight, fillMaxWidth, fillMaxSize
// matches the size of the Box after all other children have been measured 
// to obtain the Box's size.
matchParentSize

heighIn(min, max), widthIn(min, max) Gesture Modifiers combinedClickable(onLongClick, onDoubleClick, onClick)

draggable(
  orientation = Orientation.Horizontal,
  state = rememberDraggableState { delta ->
    val newValue = offsetPosition.value + delta
    offsetPosition.value = newValue.coerceIn(minPx, maxPx)
  }
)

swipeable(
  state = swipeableState,
  anchors = anchors,
  thresholds = { _, _ -> FractionalThreshold(0.3f) },
  orientation = Orientation.Horizontal
)

pointerInput(Unit) {
  detectTapGestures(onPress, onDoubleTap, onLongPress, onTap)
  detectDragGestures { change, dragAmount ->
    change.consumeAllChanges()
    offsetX += dragAmount.x
    offsetY += dragAmount.y
  }
}

horizontalScroll, verticalScroll

// Detects the scroll gestures, but does not offset its contents.
// Has nested scroll built in
scrollable

nestedScroll(nestedScrollConnection, nestedScrollDispatcher) Miscelaneous LocalSoftwareKeyboardController val keyboardController = LocalSoftwareKeyboardController.current
// Calling this function is considered a side-effect and should not be called directly from recomposition
keyboardController.hide() LocalOnBackPressedDispatcherOwner and BackHandler var backHandlingEnabled by remember { mutableStateOf(true) }
var backPressedCount by remember { mutableStateOf(0) }
BackHandler(backHandlingEnabled) { backPressedCount++ }

val dispatcher = LocalOnBackPressedDispatcherOwner.current!!.onBackPressedDispatcher

Button(onClick = { dispatcher.onBackPressed() }) {
  Text("Press Back count $backPressedCount")
} LocalDensity val sizeInPx = with(LocalDensity.current) { 16.dp.toPx() }
val (minPx, maxPx) = with(LocalDensity.current) { min.toPx() to max.toPx() } FocusRequester val focusRequester = remember { FocusRequester() }
var color by remember { mutableStateOf(Black) }
Box(
  Modifier
    .clickable { focusRequester.requestFocus() }
    .border(2.dp, color)
    // The focusRequester should be added BEFORE the focusable.
    .focusRequester(focusRequester)
    // The onFocusChanged should be added BEFORE the focusable that is being observed.
    .onFocusChanged { color = if (it.isFocused) Green else Black }
    .focusable()
) Thank you for reading. If you have any suggestions feel free to contact me. Resources https://developer.android.com/jetpack/compose/architecture https://developer.android.com/jetpack/compose/resources https://developer.android.com/jetpack/compose/animation https://developer.android.com/jetpack/compose/gestures https://developer.android.com/jetpack/compose/navigation https://developer.android.com/jetpack/compose/modifiers-list https://developer.android.com/jetpack/compose/mental-model https://developer.android.com/jetpack/compose/compositionlocal https://developer.android.com/codelabs/jetpack-compose-basics https://developer.android.com/codelabs/jetpack-compose-layouts https://developer.android.com/codelabs/jetpack-compose-state https://developer.android.com/codelabs/jetpack-compose-theming https://developer.android.com/codelabs/jetpack-compose-animation https://developer.android.com/codelabs/jetpack-compose-navigation https://developer.android.com/codelabs/jetpack-compose-advanced-state-side-effects https://developer.android.com/reference/kotlin/androidx/compose/runtime/saveable/package-summary Also published . here

The Ultimate Jetpack Compose Cheat Sheet

This is the second and last part of my series which focuses on Anomaly Detection using Machine Learning. If you haven't already, I recommend you read my first article which will introduce you to Anomaly Detection and its applications in the business world. here In this article, I will take you through a case study focus on . It is important that credit card companies are able to recognize fraudulent credit card transactions so that customers are not charged for items that they did not purchase. So the main task is to identify fraudulent credit card transactions by using Machine learning. We are going to use a Python library called which is specifically developed for anomaly detection purposes. Credit Card Fraud Detection PyOD What is the PyOD Library? PyOD is a comprehensive and scalable for in multivariate data. It has around 20 outlier detection algorithms (supervised and unsupervised). PyOD is developed with a comprehensive API to support multiple techniques and you can take a look at the official documentation of PyOD . Python toolkit detecting outlying objects here If you are an anomaly detection professional or you want to learn more about anomaly detection then I recommend you try using the PyOD Toolkit. Features of PyOD PyOD has useful features such as : Unified APIs, detailed documentation, and interactive examples across various algorithms. Advanced models, including Neural Networks/Deep Learning and Outlier Ensembles. Optimized performance with JIT and parallelization when possible, using and . numba joblib Compatible with both Python 2 & 3.(support for python 2 ended January 2020). Installing PyOD in Python Let’s first install PyOD on our machines. pip install pyod pip install --pre pyod # normal install # pre-release version for new features Alternatively, you could clone and run the setup.py file. git clone https://github.com/yzhao062/pyod.git
cd pyod
pip install . If you plan to use Neural Network-based Models in Pyod, you have to install Keras and other libraries manually in your machine. Credit Card Fraud Detection Case Study The dataset we will use contains transactions made by credit cards in September 2013 by European cardholders. The dataset has been collected and analyzed during a research collaboration of Worldline and the of ULB (Université Libre de Bruxelles) on big data mining and fraud detection. Machine Learning Group Now let us see how we can use the PYOD library in this case study. We will start by importing important packages such as pandas, numpy,sklearn and pyod. pandas pd numpy np scipy sklearn matplotlib.pyplot plt seaborn sns sklearn.model_selection train_test_split sklearn.metrics classification_report, accuracy_score,confusion_matrix sklearn.ensemble IsolationForest sklearn.neighbors LocalOutlierFactor pyod.models.knn KNN pyod.models.ocsvm OCSVM pyod.utils.data evaluate_print pyod.utils.example visualize sklearn.preprocessing StandardScaler cf_matrix make_confusion_matrix 
%matplotlib inline warnings 
warnings.filterwarnings( ) np.random.seed( ) # Import important packages import as import as import import import as import as from import from import from import from import # Importing KNN module from PyOD from import from import # Import the utility function for model evaluation from import from import from import from import import 'ignore' # set seed 123 The dataset for this case study can be downloaded . here Let's load the dataset. data = pd.read_csv( ) # Load the dataset from csv file by using pandas "creditcard.csv" Check columns in the dataset. data.columns # show columns The dataset contains 31 columns, only 3 columns make sense which are Time, Amount, and Class (fraud or not fraud). The rest of the 28 columns were transformed using PCA dimensionality reduction in order to protect user identities. data.shape

( , ) # print the shape of the data 284807 31 The dataset contains 284807 rows and 31 columns as explained before. data.head() # show the first five rows You can see all transformed columns are named from V1 to V28. Let's check if we have any missing values in our dataset. data.isnull().sum() #check missing data We don't have any missing values in our dataset. Our target column is Class contains two classes which are fraud labeled as and not fraud labeled as 1 0. data.Class.value_counts(normalize= ) # determine number of fraud cases in our  file True In this dataset, there are only 0.173% (total of 492 )of fraud transactions and 99.82% (total of 284,315) of valid transactions. We can observe if variables in the dataset are correlated to each other by using the heatmap plot implemented in the seaborn library. corr = data.corr() 

fig = plt.figure(figsize=( , ))

sns.heatmap(corr, vmax= , square= ,annot= ) #find the correlation betweeen the variables 30 20 .8 True True The above correlation graph shows that has a strong positive correlation to the while the has a strong negative correlation to the V11 variable Class variable V17 variable Class variable. Because we have many valid transactions, we will use all 10,000 valid cases and 492 fraud cases to create our models. positive = data[data[ ]== ]
negative = data[data[ ]== ]


print( .format(len(positive)))
print( .format(len(negative)))

new_data = pd.concat([positive,negative[: ]]) new_data = new_data.sample(frac= ,random_state= )


new_data.shape # use sample of the dataset "Class" 1 "Class" 0 "positive:{}" "negative:{}" 10000 #shuffling our dataset 1 42 : 492 Positive : 284315 Negative (10492,31) Now we have a total of 10492 numbers of rows. We will standardize the Amount variable by using the method from sklearn. StandardSclaer transforms the data to where there is a mean of 0 and a standard deviation of 1, which means standardizing the data into a normal distribution. standardScaler new_data[ ] = StandardScaler().fit_transform(new_data[ ].values.reshape( , )) #Normalising the amount column. 'Amount' 'Amount' -1 1 Separate the dataset into independent variables and target variable (class variable). NB. we are not going to use the time variable in this article. X = new_data.drop([ , ], axis= ) 
y = new_data[ ] print( .format(X.shape)) 
print( .format(y.shape))
X shape: ( , )
y shape: ( ,) # split into independent variables and target variable 'Time' 'Class' 1 'Class' # show the shape of x and y "X shape: {}" "y shape: {}" 10492 29 10492 Split the dataset into train and test sets. We will only use 20% of the dataset for the test set and the rest will be the train set. X_train, X_test, y_train,y_test = train_test_split(X,y, test_size = , stratify=y, random_state= ) #split the data into train and test 0.2 42 Creating Models We will create two outlier detectors from PyOD library which are K-Nearest Neighbors Detector and One-class SVM detector. 1. k-Nearest Neighbors Detector In KNN detector for any observation, its distance to its kth nearest neighbor could be viewed as the outlying score. PyOD supports three detectors: kNN Uses the distance of the kth neighbor as the outlier score. Largest: Uses the average of all k neighbors as the outlier score. Mean: Uses the median of the distance to k neighbors as the outlier score. Median: clf_knn = KNN(contamination= , n_neighbors = ,n_jobs= )

clf_knn.fit(X_train) # create the KNN model 0.172 5 -1 The two parameters we passed into KNN() are The amount of anomalies in the data which for our case = 0.0172 contamination: Number of neighbors to consider for measuring the proximity. n_neighbors: After training our KNN Detector model, we can get the prediction labels on the training data and then get the outlier scores of the training data. The higher the scores are, the more abnormal. This indicates the overall abnormality in the data. These features make a great utility for anomaly detection tasks. PyOD y_train_pred = clf_knn.labels_ y_train_scores = clf_knn.decision_scores_ # Get the prediction labels of the training data # binary labels (0: inliers, 1: outliers) # Outlier scores We can evaluate with respect to the training data. provides a handy function for this task called The default metrics include and Precision @ n. We will pass class name, y_train values and y_train_scores(outlier scores as returned by a fitted model.) KNN() PyOD evaluate_print(). ROC valuate_print(‘KNN’, y_train, y_train_scores) # Evaluate on the training data e KNN ROC: 0.9566, precision @ rank n:0 0.5482. We see that the model has a good performance on the training data. Let’s plot the confusion matrix for the train set. KNN() scikitplot skplt skplt.metrics.plot_confusion_matrix(y_train,y_train_pred, normalize= ,title=”Consfusion Matrix on Train Set”)
 plt.show() import as # plot the comfusion matrix in the train set False 372 fraud cases were predicted correctly and only 22 cases were predicted incorrectly as valid cases in the train set. We will use decision_function to predict anomaly scores of the test set using the fitted detector(KNN Detector) and evaluate the results. y_test_scores = clf_knn.decision_function(X_test) evaluate_print( , y_test,y_test_scores) # outlier scores # Evaluate on the training data 'KNN' KNN ROC:0.9393, precision @ rank n:0.5408 Our model continues to perform well on the test set. Let’s plot the confusion matrix for the test set. KNN() y_preds = clf_knn.predict(X_test)

skplt.metrics.plot_confusion_matrix(y_test,y_preds, normalize= ,
                                    title= )
plt.show() # plot the comfusion matrix  in the test set False "Consfusion Matrix on Test Set" 87 fraud cases were predicted correctly and only 11 cases were predicted incorrectly as valid cases in the test set. 2. One-class SVM detector This is an unsupervised Outlier detection algorithm and a wrapper of scikit-learn one-class SVM Class with more functionalities. Let's create a Once-class SVM model. clf_ocsvm = OCSVM(contamination= )

clf_ocsvm.fit(X_train) # create the OCSVM model 0.172 After training our OCSVM Detector model, we can get the prediction labels on the training data and then get the outlier scores of the training data. y_train_pred = clf_ocsvm.labels_ clf_name = y_train_scores = clf_ocsvm.decision_scores_ evaluate_print(clf_name, y_train, y_train_scores) # Get the prediction labels of the training data # binary labels (0: inliers, 1: outliers) 'OCSVM' # Outlier scores # Evaluate on the training data OCSVM ROC:0.9651, precision @ rant n:0.7132 OCSVM model performs better than KNN model on the train set. Let’s plot the confusion matrix for the train set. skplt.metrics.plot_confusion_matrix(y_train,y_train_pred, 
                                    normalize= ,
                                    title= )
plt.show() # plot the comfusion matrix  in the train set False "Consfusion Matrix on                 
                                    Train Set" 373 fraud cases were predicted correctly and only 21 cases were predicted incorrectly as valid cases in the train set. We will use decision_function to predict anomaly scores of the test set using the fitted detector(OCSVM Detector) and evaluate the results. y_test_scores = clf_ocsvm.decision_function(X_test) evaluate_print(clf_name, y_test,y_test_scores) # outlier scores # Evaluate on the training data OCSVM ROC: 0.9571, precision @ rank n:0.6633 Our OCSVM model continues to perform well on the test set. Let’s plot the confusion matrix for the test set. y_preds = clf_ocsvm.predict(X_test) 
skplt.metrics.plot_confusion_matrix(y_test,y_preds, normalize= , title=”Consfusion Matrix on Test Set”, ) plt.show() # plot the comfusion matrix in the test set False 92 fraud cases were predicted correctly and only 6 cases were predicted incorrectly as valid cases in the test set. In general, when you compare these two models, we observed that the OCSVM model performs better than the KNN model. There is more that can be done to increase the performance of the best model (OCSVM) for detecting fraud transactions. You can also try to use other detector algorithms found on . PyOD documentation Conclusion It is important that credit card companies are able to recognize fraudulent credit card transactions so that customers are not charged for items that they did not purchase. As a business owner, you can avoid serious headaches and unwanted publicity by recognizing potentially fraudulent use of credit cards in your payment environment. The source code for this article is available on Github. https://github.com/Davisy/Credit-Card-Fraud-Detection-using-PYOD-Library If you learned something new or enjoyed reading this article, please share it so that others can see it.I look forward to hearing your experience using PyOD Library as well. I can also be reached on Twitter @Davis_McDavid Also published at https://medium.com/analytics-vidhya/introduction-to-anomaly-detection-using-machine-learning-with-a-case-study-part-two-f78243f74d2f

Credit Card Fraud Detection via Machine Learning: A Case Study

series Scopes, Hoisting, Closures Javascript fundamentals , we have gone deep into the Global Scope, first part of understanding scopes in Javascript. If you feel insecure, or want to take a quick look, I encourage you to read it first since we will be referring to global scope in this article. In previous article If you have ever written any piece of Javascript code, you probably already created local scope and exploited its benefits since it is almost impossible not to. I am saying that because if you ever create a variable inside a function, you just create a local scope, not a global one. Local Scope occurs when you create a variable inside a function. By doing that, the visibility and accessibility of the variable changes significantly. Any variable created inside yellow box is a local variable, just like any variable inside blue box is a global one. To make it super easy to understand, blue box represents the global scope while yellow box represents the local scope. Of course to understand local variable/scope is not possible with one image and a description. Let’s take a look another image. Yes, local scope is different than global variable and more complicated to understand. This demo shows the basic behavior/concept about local scope. If you create different functions, you basically create different scopes for every one of them. To understand the basic behavior, we can work with console and see the errors and accessibility of variables in different scopes. globalOne= ; { localOne= ; .log(localOne); .log(globalOne); }
testingScope() .log(localOne); .log(globalOne); var 16 ( ) function testingScope var 12 console // 12 console // 16 // 12 and 16 console // Uncaught ReferenceError: localOne is not defined console // 16 Since our variable is a global variable, we can access it anywhere. However, variable is only accessible inside its scope. That’s why, if we call testingScope function, we can see both variables in the console. globalOne localOne In global scope, we can only access global variables, stored in window object. Unlike global variables, local variables are not accessible and are destroyed as soon as their scope ends. They stay in memory when their function, which they are created in, is called. That’s why they are only accessible during execution of their function. That is one of the key differences between global and local variables. Difference between function scope and block scope Up to now, we have seen local scope but actually I was not super clear. In reality, local scope can be divided into two scopes: Function Scope and Block Scope. Until ES6, Javascript only had function scope which is actually what I have been explaining so far. Function Scope occurs when a variable is defined inside of a function. It is simple as that. Block Scope, on the other hand, is introduced with ES6 and is a little bit of different. You can create subset of a function scope with a block scope. If you use blocks, , like if, switch, for, while, you can make use of block scope only if you define variable with . It is a long sentence and I think I can explain better if I show it in the console. anything between {} let and const (‘anything returning ’){ localVariable= ; otherLocalVariable= ; .log(localVariable); .log(otherLocalVariable); } .log(localVariable) .log(otherLocalVariable) if true let 12 var 10 console // 12 console // 10 console // Uncaught ReferenceError: localVariable is not defined console // 10 Do you see their behavior? , defined with , is only visible inside the block. , defined with , is visible outside the block. Different behavior is because of the difference between var, let, const. Therefore, it is important to know the differences of them to understand block scope. localVariable let otherLocalVariable var Variable Shadowing If you are going to reassign a variable in a function, there is a concept you should know about: Variable Shadowing. In Javascript, when you define a variable in global scope and then in local scope, local one takes precedence. Of course they have to share the same name. In global scope, variable stays with its initial value, but in local scope, its value changes to whatever you reassigned. Let’s see an example: simpleVariable=’global scope’ {
simpleVariable=’local scope’; .log(simpleVariable);
}
testingVariableShadowing(); .log(simpleVariable); let ( ) function testingVariableShadowing // reassignment console // local scope console // global scope In global scope, value is still ‘global scope’ while when it is called in function scope, it changes to ‘local scope’. simpleVariable’s If you would like to read more about Javascript Fundamentals, please take a look at the Learn Javascript Fundamentals Series. 1. Global Scope 2. Local Scope 3. Scope, Context, Execution Context Happy Coding!!!

Learn Javascript Fundamentals-Local Scope

This rather long post steps you through the process of setting up a on a Zero W or Raspberry Pi 3. There are a number of reasons why you might want to do such a thing: WiFi router Raspberry Pi Setup a demo any where access point for your web apps Create deployable devices for use in network testing. As an added bonus this post also describes how to install NodeJS and the AWS command line tool to created scripted workflows with AWS. Setting up the Raspberry Pi Setup the Raspberry Pi Zero W using . The version I used was Raspbian Lite 2018-06-27-raspbian-stretch-lite.img The following instructions are Mac OSX centric but not too different for how you’d do this using other operating systems. Locate SD card On Mac you can do this using diskutil via the command line. Execute the command below and look for a /dev/disk that matches the size of your SD card. For me, that’s /dev/disk2 $ diskutil list Unmount the SD card Next unmount the SD card using the disk number. $ diskutil unmountDisk /dev/disk2 Flash the OS image Use the command to flash the Raspbian lite image onto your SD card. Be careful when doing this! dd This is a good time to mention that the command can be very dangerous if you're not careful using it. Always make sure that you're pointing to the correct disk drive! You wouldn't want to erase the wrong drive. After all, there's a reason why the command is known as the Disk Destroyer, but that's not what dd stands for. See this bit of history if you're interested. dd dd [dd](https://en.wikipedia.org/wiki/Dd_%28Unix%29) $ sudo dd bs=1m if=./2018-06-27-raspbian-stretch-lite.img of=/dev/disk2 conv=sync While dd is running you can press ctrl-t on your keyboard to check on the status. The SD disk flash can take a while based on the speed of your SD card. It’s recommended that you use a Class 6 or Class 10 microSDHC card for performance reasons. Once the copy completes you can cd onto the card: $ cd /Volumes/boot Create an empty ssh file to tell the OS that you wish to enable SSH access: $ touch ssh Next create a file with the following, make sure to replace your ssid and psk fields with your router's settings. wpa_supplicant.conf ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdevupdate_config=1country=USnetwork={    ssid="YOUR-SSID"    psk="YOUR-PASSWORD"    scan_ssid=1} Safely unmount the SD after your changes. $ cd ~$ diskutil unmountDisk /dev/disk2 Connecting to and configuring your Raspberry Pi Next, insert the SD into your Pi Zero and boot the device. Give that a minute or so to complete then try pinging the device to locate it. $ ping raspberrypi.local Or locate the device using your network router or a Wifi scanner such as Who’s on My Wifi You can ssh into the device using: $ ssh pi@raspberrypi.localor$ ssh pi@10.10.0.107 The default password is . raspberry If you encounter the following error: @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ WARNING: POSSIBLE DNS SPOOFING DETECTED! @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ then simply edit your file and remove the line that has the entry. .ssh/known_hosts raspberrypi $ vi /Users/${USER}/.ssh/known_hosts So moving right along, once you sign in, the first order of business is to change the password! $ passwd The username will still remain but you'll be able to sign in using your new password. pi You can optionally proceed to make other tweaks using the raspi-config utility if you’d like. $ sudo raspi-config Next make sure the OS is up to date: $ sudo apt-get update A note regarding the update command above: if while installing packages you get an error such as **_E: Unable to fetch some archives, maybe run apt-get update or try with — fix-missing?_** Then rerun **_sudo apt-get update_** and retry the package update that failed. This has proven to be successful. Lastly, here take a moment to setup your timezone: $ sudo dpkg-reconfigure tzdata Adding NodeJS For the Pi ZeroW use: $ mkdir nodejs; cd nodejs$ wget $ tar -xvf node-v8.12.0-linux-armv6l.tar.xz$ cd /usr/local/bin$ sudo cp /home/pi/nodejs/node-v8.12.0-linux-armv6l/bin/node .$ sudo ln -sf /home/pi/nodejs/node-v8.12.0-linux-armv6l/bin/npx npx$ sudo ln -sf /home/pi/nodejs/node-v8.12.0-linux-armv6l/bin/npm npm$ cd ~ https://nodejs.org/dist/v8.12.0/node-v8.12.0-linux-armv6l.tar.xz If using a Raspberry Pi 3 use: $ mkdir nodejs; cd nodejs$ wget $ tar -xvf node-v10.14.0-linux-armv7l.tar.xz$ cd /usr/local/bin$ sudo cp /home/pi/nodejs/node-v10.14.0-linux-armv7l/bin/node .$ sudo ln -sf /home/pi/nodejs/node-v10.14.0-linux-armv7l/bin/npx npx$ sudo ln -sf /home/pi/nodejs/node-v10.14.0-linux-armv7l/bin/npm npm$ cd ~ https://nodejs.org/dist/v10.14.0/node-v10.14.0-linux-armv7l.tar.xz You can test the NodeJS install by: $ node --version Installing the AWS command line tool This is an optional step but is useful if you have files in an S3 bucket that you’d like to copy into the Raspberry Pi. $ sudo apt-get install awscli Next configure AWS access: $ aws configureAWS Access Key ID [None]: ************AWS Secret Access Key [None]: ***************************Default region name [None]: us-west-2Default output format [None]: json Download assets script #!/bin/bashmkdir -p $1aws s3 cp s3://bucketname/$1 ./$1 — recursive Usage: ./download.sh 303A0FA/teb002/3A0FA-2018/10/18/90918447–2fnaodyxhbr Setup as a Router steps provided by with some changes below: https://medium.com/@ivaylov/raspberry-pi-wifi-router-82921ed2ac17 Remove WPA Supplicant $ sudo apt-get purge wpasupplicant Install an DHCP server $ sudo apt-get install isc-dhcp-server Setup DHCP $ sudo vi /etc/dhcp/dhcpd.conf Add to end of file: subnet 172.16.1.0 netmask 255.255.255.0 {range 172.16.1.25 172.16.1.50;option domain-name-servers 8.8.4.4;option routers 172.16.1.1;interface wlan0;} Install the host access point daemon $ sudo apt-get install hostapd Configure hostapd Create a hostapd.conf file $ sudo vi /etc/hostapd/hostapd.conf add these lines to hostapd.conf file interface=wlan0#driver=nl80211ssid=YOUR_STATIONhw_mode=gchannel=5wpa=1wpa_passphrase=SECRETPASSWORDwpa_key_mgmt=WPA-PSKwpa_pairwise=TKIP CCMPwpa_ptk_rekey=600macaddr_acl=0 Moving right along… $ sudo ifconfig wlan0 172.16.1.1$ sudo /etc/init.d/isc-dhcp-server restart -d is for debug mode so you can see if any errors appear $ sudo hostapd -d /etc/hostapd/hostapd.conf Might need to ctrl-c after ^^^ Now lets make these changes persistent $ sudo vi /etc/network/interfaces Next, add or edit these following line auto wlan0iface wlan0 inet staticaddress 172.16.1.1netmask 255.255.255.0 Edit rc.local … $ sudo vi /etc/rc.local and add two lines before the last line exit 0 hostapd -B /etc/hostapd/hostapd.confiptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE Then uncomment the following line in /etc/sysctrl.conf $ sudo vi /etc/sysctl.conf # Uncomment the next line to enable packet forwarding for IPv4#net.ipv4.ip_forward=1 So above should read: net.ipv4.ip_forward=1 That’s it. We can now reboot the box. $ sudo reboot Testing At this stage you should be able to access the WiFi network. — Thanks for reading! If you like what you read, hold the clap button below so that others may find this. You can also follow me on Twitter .

Stories, News & Mentions about ALOCALO

Alocalo’s Stories on HackerNoon

Alocalo's News & Mentions