At Common Room, we’re building more than the tools that help organizations build and nurture their communities—we’re building a whole new way of working with the people that matter most

Common Room

commonroom

John Grey Goes a Second Time to London

1811 Dictionary in the Vulgar Tongue: Section D

Great Expectations, by Charles Dickens is part of HackerNoon’s Book Blog Post series. You can jump to any chapter in this book here. Chapter X. The felicitous idea occurred to me a morning or two later when I woke, that the best step I could take towards making myself uncommon was to get out of Biddy everything she knew. In pursuance of this luminous conception I mentioned to Biddy when I went to Mr. Wopsle’s great-aunt’s at night, that I had a particular reason for wishing to get on in life, and that I should feel very much obliged to her if she would impart all her learning to me. Biddy, who was the most obliging of girls, immediately said she would, and indeed began to carry out her promise within five minutes. The Educational scheme or Course established by Mr. Wopsle’s great-aunt may be resolved into the following synopsis. The pupils ate apples and put straws down one another’s backs, until Mr. Wopsle’s great-aunt collected her energies, and made an indiscriminate totter at them with a birch-rod. After receiving the charge with every mark of derision, the pupils formed in line and buzzingly passed a ragged book from hand to hand. The book had an alphabet in it, some figures and tables, and a little spelling,—that is to say, it had had once. As soon as this volume began to circulate, Mr. Wopsle’s great-aunt fell into a state of coma, arising either from sleep or a rheumatic paroxysm. The pupils then entered among themselves upon a competitive examination on the subject of Boots, with the view of ascertaining who could tread the hardest upon whose toes. This mental exercise lasted until Biddy made a rush at them and distributed three defaced Bibles (shaped as if they had been unskilfully cut off the chump end of something), more illegibly printed at the best than any curiosities of literature I have since met with, speckled all over with ironmould, and having various specimens of the insect world smashed between their leaves. This part of the Course was usually lightened by several single combats between Biddy and refractory students. When the fights were over, Biddy gave out the number of a page, and then we all read aloud what we could,—or what we couldn’t—in a frightful chorus; Biddy leading with a high, shrill, monotonous voice, and none of us having the least notion of, or reverence for, what we were reading about. When this horrible din had lasted a certain time, it mechanically awoke Mr. Wopsle’s great-aunt, who staggered at a boy fortuitously, and pulled his ears. This was understood to terminate the Course for the evening, and we emerged into the air with shrieks of intellectual victory. It is fair to remark that there was no prohibition against any pupil’s entertaining himself with a slate or even with the ink (when there was any), but that it was not easy to pursue that branch of study in the winter season, on account of the little general shop in which the classes were holden—and which was also Mr. Wopsle’s great-aunt’s sitting-room and bedchamber—being but faintly illuminated through the agency of one low-spirited dip-candle and no snuffers. It appeared to me that it would take time to become uncommon, under these circumstances: nevertheless, I resolved to try it, and that very evening Biddy entered on our special agreement, by imparting some information from her little catalogue of Prices, under the head of moist sugar, and lending me, to copy at home, a large old English D which she had imitated from the heading of some newspaper, and which I supposed, until she told me what it was, to be a design for a buckle. Of course there was a public-house in the village, and of course Joe liked sometimes to smoke his pipe there. I had received strict orders from my sister to call for him at the Three Jolly Bargemen, that evening, on my way from school, and bring him home at my peril. To the Three Jolly Bargemen, therefore, I directed my steps. There was a bar at the Jolly Bargemen, with some alarmingly long chalk scores in it on the wall at the side of the door, which seemed to me to be never paid off. They had been there ever since I could remember, and had grown more than I had. But there was a quantity of chalk about our country, and perhaps the people neglected no opportunity of turning it to account. It being Saturday night, I found the landlord looking rather grimly at these records; but as my business was with Joe and not with him, I merely wished him good evening, and passed into the common room at the end of the passage, where there was a bright large kitchen fire, and where Joe was smoking his pipe in company with Mr. Wopsle and a stranger. Joe greeted me as usual with “Halloa, Pip, old chap!” and the moment he said that, the stranger turned his head and looked at me. He was a secret-looking man whom I had never seen before. His head was all on one side, and one of his eyes was half shut up, as if he were taking aim at something with an invisible gun. He had a pipe in his mouth, and he took it out, and, after slowly blowing all his smoke away and looking hard at me all the time, nodded. So, I nodded, and then he nodded again, and made room on the settle beside him that I might sit down there. But as I was used to sit beside Joe whenever I entered that place of resort, I said “No, thank you, sir,” and fell into the space Joe made for me on the opposite settle. The strange man, after glancing at Joe, and seeing that his attention was otherwise engaged, nodded to me again when I had taken my seat, and then rubbed his leg—in a very odd way, as it struck me. “You was saying,” said the strange man, turning to Joe, “that you was a blacksmith.” “Yes. I said it, you know,” said Joe. “What’ll you drink, Mr.—? You didn’t mention your name, by the bye.” Joe mentioned it now, and the strange man called him by it. “What’ll you drink, Mr. Gargery? At my expense? To top up with?” “Well,” said Joe, “to tell you the truth, I ain’t much in the habit of drinking at anybody’s expense but my own.” “Habit? No,” returned the stranger, “but once and away, and on a Saturday night too. Come! Put a name to it, Mr. Gargery.” “I wouldn’t wish to be stiff company,” said Joe. “Rum.” “Rum,” repeated the stranger. “And will the other gentleman originate a sentiment.” “Rum,” said Mr. Wopsle. “Three Rums!” cried the stranger, calling to the landlord. “Glasses round!” “This other gentleman,” observed Joe, by way of introducing Mr. Wopsle, “is a gentleman that you would like to hear give it out. Our clerk at church.” “Aha!” said the stranger, quickly, and cocking his eye at me. “The lonely church, right out on the marshes, with graves round it!” “That’s it,” said Joe. The stranger, with a comfortable kind of grunt over his pipe, put his legs up on the settle that he had to himself. He wore a flapping broad-brimmed traveller’s hat, and under it a handkerchief tied over his head in the manner of a cap: so that he showed no hair. As he looked at the fire, I thought I saw a cunning expression, followed by a half-laugh, come into his face. “I am not acquainted with this country, gentlemen, but it seems a solitary country towards the river.” “Most marshes is solitary,” said Joe. “No doubt, no doubt. Do you find any gypsies, now, or tramps, or vagrants of any sort, out there?” “No,” said Joe; “none but a runaway convict now and then. And we don’t find them, easy. Eh, Mr. Wopsle?” Mr. Wopsle, with a majestic remembrance of old discomfiture, assented; but not warmly. “Seems you have been out after such?” asked the stranger. “Once,” returned Joe. “Not that we wanted to take them, you understand; we went out as lookers on; me, and Mr. Wopsle, and Pip. Didn’t us, Pip?” “Yes, Joe.” The stranger looked at me again,—still cocking his eye, as if he were expressly taking aim at me with his invisible gun,—and said, “He’s a likely young parcel of bones that. What is it you call him?” “Pip,” said Joe. “Christened Pip?” “No, not christened Pip.” “Surname Pip?” “No,” said Joe, “it’s a kind of family name what he gave himself when a infant, and is called by.” “Son of yours?” “Well,” said Joe, meditatively, not, of course, that it could be in anywise necessary to consider about it, but because it was the way at the Jolly Bargemen to seem to consider deeply about everything that was discussed over pipes,—“well—no. No, he ain’t.” “Nevvy?” said the strange man. “Well,” said Joe, with the same appearance of profound cogitation, “he is not—no, not to deceive you, he is not—my nevvy.” “What the Blue Blazes is he?” asked the stranger. Which appeared to me to be an inquiry of unnecessary strength. Mr. Wopsle struck in upon that; as one who knew all about relationships, having professional occasion to bear in mind what female relations a man might not marry; and expounded the ties between me and Joe. Having his hand in, Mr. Wopsle finished off with a most terrifically snarling passage from Richard the Third, and seemed to think he had done quite enough to account for it when he added, “—as the poet says.” And here I may remark that when Mr. Wopsle referred to me, he considered it a necessary part of such reference to rumple my hair and poke it into my eyes. I cannot conceive why everybody of his standing who visited at our house should always have put me through the same inflammatory process under similar circumstances. Yet I do not call to mind that I was ever in my earlier youth the subject of remark in our social family circle, but some large-handed person took some such ophthalmic steps to patronise me. All this while, the strange man looked at nobody but me, and looked at me as if he were determined to have a shot at me at last, and bring me down. But he said nothing after offering his Blue Blazes observation, until the glasses of rum and water were brought; and then he made his shot, and a most extraordinary shot it was. It was not a verbal remark, but a proceeding in dumb-show, and was pointedly addressed to me. He stirred his rum and water pointedly at me, and he tasted his rum and water pointedly at me. And he stirred it and he tasted it; not with a spoon that was brought to him, but with a file. He did this so that nobody but I saw the file; and when he had done it he wiped the file and put it in a breast-pocket. I knew it to be Joe’s file, and I knew that he knew my convict, the moment I saw the instrument. I sat gazing at him, spell-bound. But he now reclined on his settle, taking very little notice of me, and talking principally about turnips. There was a delicious sense of cleaning-up and making a quiet pause before going on in life afresh, in our village on Saturday nights, which stimulated Joe to dare to stay out half an hour longer on Saturdays than at other times. The half-hour and the rum and water running out together, Joe got up to go, and took me by the hand. “Stop half a moment, Mr. Gargery,” said the strange man. “I think I’ve got a bright new shilling somewhere in my pocket, and if I have, the boy shall have it.” He looked it out from a handful of small change, folded it in some crumpled paper, and gave it to me. “Yours!” said he. “Mind! Your own.” I thanked him, staring at him far beyond the bounds of good manners, and holding tight to Joe. He gave Joe good-night, and he gave Mr. Wopsle good-night (who went out with us), and he gave me only a look with his aiming eye,—no, not a look, for he shut it up, but wonders may be done with an eye by hiding it. On the way home, if I had been in a humour for talking, the talk must have been all on my side, for Mr. Wopsle parted from us at the door of the Jolly Bargemen, and Joe went all the way home with his mouth wide open, to rinse the rum out with as much air as possible. But I was in a manner stupefied by this turning up of my old misdeed and old acquaintance, and could think of nothing else. My sister was not in a very bad temper when we presented ourselves in the kitchen, and Joe was encouraged by that unusual circumstance to tell her about the bright shilling. “A bad un, I’ll be bound,” said Mrs. Joe triumphantly, “or he wouldn’t have given it to the boy! Let’s look at it.” I took it out of the paper, and it proved to be a good one. “But what’s this?” said Mrs. Joe, throwing down the shilling and catching up the paper. “Two One-Pound notes?” Nothing less than two fat sweltering one-pound notes that seemed to have been on terms of the warmest intimacy with all the cattle-markets in the county. Joe caught up his hat again, and ran with them to the Jolly Bargemen to restore them to their owner. While he was gone, I sat down on my usual stool and looked vacantly at my sister, feeling pretty sure that the man would not be there. Presently, Joe came back, saying that the man was gone, but that he, Joe, had left word at the Three Jolly Bargemen concerning the notes. Then my sister sealed them up in a piece of paper, and put them under some dried rose-leaves in an ornamental teapot on the top of a press in the state parlour. There they remained, a nightmare to me, many and many a night and day. I had sadly broken sleep when I got to bed, through thinking of the strange man taking aim at me with his invisible gun, and of the guiltily coarse and common thing it was, to be on secret terms of conspiracy with convicts,—a feature in my low career that I had previously forgotten. I was haunted by the file too. A dread possessed me that when I least expected it, the file would reappear. I coaxed myself to sleep by thinking of Miss Havisham’s, next Wednesday; and in my sleep I saw the file coming at me out of a door, without seeing who held it, and I screamed myself awake. About HackerNoon Book Series: We bring you the most important technical, scientific, and insightful public domain books. This book is part of the public domain. Dickens, Charles, 1998. Great Expectations. Urbana, Illinois: Project Gutenberg. Retrieved April 2022 from https://www.gutenberg.org/files/1400/1400-h/1400-h.htm#chap10 This eBook is for the use of anyone anywhere at no cost and with almost no restrictions whatsoever. You may copy it, give it away or re-use it under the terms of the Project Gutenberg License included with this eBook or online at www.gutenberg.org , located at https://www.gutenberg.org/policy/license.html .

Great Expectations: Chapter X

Remote work is not something new that has surfaced in recent times. But With the COVID-19 pandemic – It has become much more relevant and necessary to the global workforce eyeing for revival. In the previous decade, remote work saw a whopping increase of 159% in the US, according to the flex jobs. And now, when the whole world is battling with the pandemic, there is a gradual shift to remote work economy. This sudden shift – not only ensures health safety but also enhances efficiency of the existing workforce. There are numerous advantages when it comes to working remotely. According to the stats, working away from the workplace reduced the cost by 77%, boosted employee morale by 90%, reduced sick days by 50%, and elevated satisfaction level to 57%. These stats are impressive from both the employee and the employer's point of view. The benefits by working from home are quite remarkable that assist in boosting productivity, lowering stress, and increasing satisfaction level. However, along with these great benefits, there lie several challenges that become an overarching barrier to the overall concept of remote working. Indeed, visualizing a remote economy without dealing with the existing downsides is entirely impossible. What are those barriers? How do they affect the remote workers? And How to deal with those challenges effectively? Let’s explore further in the post. 1. Adjusting to Virtual Communication Communication is essential when it comes to remote working. Employers disperse the necessary information at the workplace that helps workers determine the scope of work and deadline within which they need to finish off a particular duty. Unfortunately, virtual communication, which is an integral part of remote working, can be a hurdle between employees and employers if not implemented right. Adjusting to this virtual communication requires proper training and directions. It is also significant so that the employees don’t feel socially disconnected, isolated and uninformed. 2. Distractions and Interruptions While working away from your workplace, distractions and interruptions are frequent. When you work at home, you are much more relaxed and a little focused on the task that needs to be completed. And, even the smallest disturbance around you – takes away your whole concentration levels. The cause of the distraction can be anything. Your pet roaming around, the buzz among your family members or a visitor on the door seeking attention. The best ways to deal with distractions are: Pick up the right spot and time to accomplish your task. Night time is perfect to work if your employer offers you such flexibility. Choose a room or corner where you are much likely to focus on your work. Isolating yourself from others is the first step toward higher productivity. Prioritize your tasks and take a resolution to complete them on time. If you cannot find a peaceful environment, try earpieces to reduce unwanted sounds that are fundamentally distractive. Keep unwanted communications at bay and build consistency. 3. Time Management Time management is the key to achieve discipline and focus during the entire remote working journey. Time management is already an essential component for freelancers working on the freelance marketplace to ensure the highest work standards. According to the , “there are more than 15 freelance platforms where you need to be right on the money when it comes to time management”. If you don’t manage time carefully, you’re surely risking your reputation among clients. Hence, time management is always critical to freelance success. To the employee for whom remote working is something new, time management can be an arduous task. A miserable schedule can result in unorganized tasks, missed deadlines, and poor quality of work. However, there are ways you can always manage time effectively. Here are some of them: Heck Oh Yeah blog Use time management software such as Timecamp, Clockify, or Toggl. Make a to-do list Prioritize tasks based on the deadline. 4. Overworking The biggest challenge for employers is getting the same level of efficiency from the workers. When the workers are not in sight, the risk is that they might slack off. However, the trend in remote work is just the opposite. Workers tend to overwork when both personal and professional life is mingled. The prime reason for such overworking is that it is hard to switch off when the professional and personal life is considerably intermixed and conducted under one roof. This situation often results in indefinite work without taking breaks. And, this often leads to poor mental health and burnout. To avoid this situation, here is what you can do: Set reminders on the calendar for the end of the workday. It is a great way to maintain work-life balance and allow your brain to recover from work-related stress. Afterwards, you can go shopping, follow your fitness regime and do all your favorite things that bring back your energy levels to normal. Set-up reminder for breaks. Taking breaks is as vital as completing essential tasks. A to-do list can help you manage interruptions and help you recondition your mind and body. Create physical boundaries between the office and other home areas. If you have a dedicated space, it can work well or make a partition in your common room. 5. Social Isolation Striking a balance between working and personal life is essential. Too much desolation can result in being cut-off by other people and isolate you from the outer world. Isolation does not only severely impact your overall brain health but also in tandem cause to lower your productivity levels. And, in times like COVID-19 is common. To avoid social isolation it, here is what to do. social isolation Join a local or recreational community. Be more social. Talk to your friends, family members, and anyone around. Build social work-spaces where you can express yourself better and light-up your mind by starting great conversations. 6. Accessible Technology Technology plays a significant role in working on a remote site. It can be internet coverage, video streaming tools, and your computer or communication software. It is always necessary to have technology beforehand to navigate and complete communication and project delivery effortlessly. Perhaps, there are moments when you have to deal with power outages, computer technical issues, internet speed problems, and many. The best way to overcome them is always to have a backup plan ready. And that is not only one plan. You got to have a plan A and plan B. Therefore, and you can instantly switch-off between plans in case of contingency. 7. Time Zone Differences Sometime teeming up is crucial to complete a project. While working remotely, collaboration can be a problem. If your team member is in a different time zone, it can get even more complicated. Different time zones can result in unnecessary waiting times when you have to simply rely on your team member’s answers to a critical question or project supervision on an immediate basis. And, it certainly can feel you out of touch. To solve this problem, you can recommend your team to work on an overlap period. A fixed overlap period can allow you and your team members to exchange work-related information and project communication. And, this will undoubtedly result in timely project completion and fewer delays. The Ball is Rolling Undoubtedly, the future of jobs is remote working. While the remote working which is the new normal for the global workforce, it is pretty much accidental. Adjusting and adapting to this normal would take rewarding adjustments in mindset and environment. Remember, when you adjust to these challenges, you enjoy greater flexibility, productivity, and opportunities for a better work-life. It’s Time for you to transform the Remote Job Arena What is the biggest challenge for you when it comes to remote working? And how did you overcome them. Any tips you would like to share? Drop them in the comments below, I would love to hear them up.

7 Challenges to a Remote Work Economy and How to Deal with Them

This post is part of a larger attempt to share my personal “systems” that help me organize my life. By sharing my system, I hope to get feedback and inspire others to share as well. Minimalism: Living with Nothing I started becoming a minimalist two years ago, inspired by sites like and Marie Kondo’s . I quickly got addicted to reducing my possessions, and found more and more ways to declutter. I now have only 115 items! There are three main reasons I’m a minimalist fanboy: The Minimalists The Life Changing Magic of Tidying Up — I don’t have messes anymore and I rarely worry about losing items. Reduced cognitive overload Focusing on as opposed to material-based happiness. I seldom found long-term joy in the physical items I purchased for myself. experience-based happiness Being a minimalist has allowed me much more , for example, freeing up the money I would have spent on a new bed frame so that I can invest the money. financial freedom I’ve outlined exactly the 115 items that I own now, although I’m still working on decreasing this number. I hope this inspires others to share their material systems, and I want to highlight some key multi-purpose items that allow my list to be so short. My three favorite minimalist items These items are great because they’re multi-purpose, compact, and very cheap, so I don’t worry about damaging or losing them. Radix One Slim Wallet ( ) Amazon Link Curious what’s inside my wallet? Check out my . financial break-down article Foldable Storage Ottoman ( ) Amazon Link Swiss Army Pocket Knife ( ) Amazon Link My full 115 items This list is a list of items that I would take with me if I were moving. It does NOT include shared items (e.g. common room couch) and it counts pairs of items as one (e.g. a pair of socks). Otherwise, I generally try to count items as separate unless they’re clearly in a “bundle” (I’ve labeled these items with “[bundle]” to clarify I’m counting them as one item). Methodology: Clothing (60) Note: not all clothing pictured 2 Eyeglasses (one backup) Eyeglasses Case 10 Pairs of Socks (including and ) Darn Tough Socks Feetures! Running Socks 14 Pairs of Underwear (Target) 10 T-shirts 4 Casual Button-down Shirts 2 Dress Shirts 2 Jeans 2 Belts Slacks Tie Khaki Shorts Board Shorts (multi-use as exercise shorts) Pajama Pants Nike Pegasus 32 Running Shoes Dress Shoes Collegiate Jacket Thick Winter Jacket Snow Jacket Light black hoodie Atif Ateeq’s “Haram” Hat Baseball Cap Toiletries (17) Generic Soft-Brush Toothbrush Generic Toothpaste Hair Comb Floss Bath Towel Body Wash Pantene Two in One Shampoo+Conditioner Medicine [bundle] Toiletries Bag Hand Towel Dove Men + Care Deodorant EltaMD Sunscreen Beard Trimmer Beard Trimmer Charger Lubriderm Men’s 3-In-1 Body Lotion Retainers Retainers Case On-the-go (7) (great for running with) Osprey Packs Quasar Daypack [bundle, including 5 cards] Radix One Slim Wallet House Key U.S. Passport Sleeping Bag Sleeping Bag Case Tote Bags [bundle] Electronics (11) Extension Cord Android Nexus 6P Smartphone Apple MacBook Pro 13 inch with Retina Display Apple MacBook Charger Bose QC 20 noise cancelling headphones Spare Earphones [bundle] Spare Chargers [bundle] WD 1TB Portable External Hard Drive Headphone Splitter Xiaomi Portable Battery Charger Travel Power Adapter Furniture (13) Twin-XL Mattress Allergy Mattress Cover (to put the mattress directly on the floor) Gray Fitted Sheet Gray Bed Sheet Navy Comforter Pillow Pillow Cover Masai Mara Blanket (from my travels in Kenya) Two (~$20 on Amazon) Foldable Storage Ottomans (can be made into a couch on the floor, or can be slept in as an extra bed) EMOOR Japanese Traditional Futon Mattress, Twin EMOOR Japanese Traditional Futon Gray Cover IKEA Laundry Basket Miscellaneous (7) Swiss Army Pocket Knife [bundle] Post-IT Notes Empty Box (for storage) Soylent Hard-bound MoleSkine Notebook Yoga Mat BUFF Multifunctional Headwear Pens [bundle] Not included in this list Shared Kitchenware (borrowed from roommates) Shared Furniture (borrowed from roommates) Consumable Items (I cycle through these on a biweekly basis) Books (I’ll donate them when I move, and I mostly use e-books — if you’re curious for more, ) here’s a post about my reading organization system If you found this interesting, you can follow me on Twitter at . Check out some of my other articles below: @stervyc The Practical Minimalist Gift Guide My Entire Financial System in One Diagram What Other Minimalists Like Me Own

How I live: My 115 things

Not bad for a movie night, but not great for a restful sleep I arrived in Vancouver a week ago with a master plan. It involved a long list of activities, including marketing like crazy and building our connection platform. All this would start out of my friends living room, and in cliché fashion, I would be sleeping on the couch. The plan seemed solid. Everyone I told it to said it was great — my parents, my close friends — I was sold. Off to Vancouver I went, to create Shift Connections with my friends Blake and Alex. The first couple of days the plan seemed flawless. The couch was better than expected, and Blake and I were already hitting tech and creative socials to share our idea and build connections. We hit the ground running, but after a few days I was running on fumes, and we were just getting started. We quickly discovered holes in our plan. In the two weeks since I’ve been in Vancouver, our marketing plan has quickly morphed from handing out business cards at meetups to a hard thought-out scientific approach. We thought we had a good handle on the product, the pitch, and the user personas, We iterated, practiced, got better. We weren’t discouraged though; we were too busy iterating. but we didn’t. I did the same thing with the couch. The first night was fine — I was so tired from traveling that I could have slept front row at a Blue Jays game. But night two was bad, and night three was worse. On top of that, I was getting sick. Things were compounding quickly. Rather than giving in and letting myself get sicker and sicker, I iterated. A bed wasn’t an option — The living room is a common room that our Airbnb-ers use to watch TV and hangout. I went to Walmart, bought a memory foam pad, a sheet, two pillows, and a blanket. So I got creative. All combined it was less than a hundred bucks. Seems expensive, but it’s an investment in my health, and my ability to work at a high clip. I keep the sheet and memory foam on all the time, and take the back cushions off to sleep. As a team, we’re just doing what a start up does — chasing perfection. We know we’ll never reach perfection, and that we’ll never be on the final iteration of our approach. Everyday our definition of our mission will improve. Hopefully the couch isn’t my bed forever. At Shift Connections we’re chasing positive growth every day. We’re doing this because learning and connecting are our passions. We believe everyone should have a chance to be in an environment that encourages their passions, and empowers their ideas, no matter how big or small they may be. Every day we strive to create this community. Every iteration we get a small step closer. Fresh Sheets — I still can’t iron mom

Iterate Everything — Even the Couch

ForkJoinPool is a special-purpose ExecutorService in Java designed for parallelizing divide-and-conquer algorithms. It is part of the java.util.concurrent package introduced in Java 7. The main idea behind ForkJoinPool is to efficiently utilize available CPU cores by recursively splitting tasks into smaller subtasks and executing them in parallel. The common pool of ForkJoinPool threads are implicitly used in Java applications whenever ForkJoinTasks are submitted for execution without explicitly specifying a custom ForkJoinPool instance. Here are some scenarios in which the common pool threads are implicitly utilized: Parallel Stream Operations: When using parallel stream operations in Java 8 or later, such as parallel() or parallelStream(), the underlying implementation may utilize the common pool threads for parallel execution of stream operations. For example:
javaCopy codeList<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.parallelStream().mapToInt(Integer::intValue).sum();




RecursiveTask and RecursiveAction: If you create instances of RecursiveTask or RecursiveAction and invoke their fork() and join() methods, the tasks are typically executed using the common pool threads. For example:
javaCopy codeclass MyRecursiveTask extends RecursiveTask<Integer> {
    @Override
    protected Integer compute() {
        // Task logic here
    }
}
MyRecursiveTask task = new MyRecursiveTask();
int result = ForkJoinPool.commonPool().invoke(task);




Task Execution by ForkJoinPool: Any ForkJoinTasks submitted to the ForkJoinPool using methods like invoke(), submit(), or execute() without specifying a custom pool instance will be executed using the common pool threads.


Parallel Array Operations: Operations on parallel arrays using Arrays.parallelSetAll(), Arrays.parallelSort(), etc., may utilize the common pool threads for parallel processing.


CompletableFuture: Operations on CompletableFuture, especially those involving asynchronous computations and combining results using methods like thenCombine() or thenApplyAsync(), may leverage the common pool threads for execution. In all these scenarios, the common pool threads are implicitly used by the Java runtime to execute tasks in parallel, taking advantage of multi-core processors and maximizing CPU utilization. Generally, it’s not advisable to use ForkJoinPool threads directly in the methods of CompletableFuture. Here's why: Reasons to Avoid Direct Usage: Conflicting Execution Models: CompletableFuture uses its own asynchronous execution mechanism, often relying on a cached thread pool or a custom executor you provide. Bypassing this mechanism and introducing ForkJoinPool threads can lead to unexpected behavior and potential thread pool management issues.
Limited Control: Using thenAsync allows CompletableFuture to manage thread pool utilization based on the workload. Direct ForkJoinPool usage might not align with this management strategy.
Blocking: ForkJoinPool is optimized for CPU-bound tasks with coarse-grained parallelism. Blocking operations within thenAsync tasks can hinder the pool's efficiency. Recommended Approach: Leverage the internal asynchronous execution mechanism of CompletableFuture. You can configure a custom executor for CompletableFuture if you have specific thread pool requirements, but it's usually not necessary for basic asynchronous tasks.
If you have CPU-bound tasks suitable for ForkJoinPool, consider processing them before using CompletableFuture. Utilize CompletableFuture for the asynchronous chaining of these pre-processed results. In summary, exercise caution while using CompletableFuture methods without passing custom executor service as it might create some unexpected behavior. ForkJoinPool is a special-purpose ExecutorService in Java designed for parallelizing divide-and-conquer algorithms. It is part of the java.util.concurrent package introduced in Java 7 . The main idea behind ForkJoinPool is to efficiently utilize available CPU cores by recursively splitting tasks into smaller subtasks and executing them in parallel. ForkJoinPool ExecutorService java.util.concurrent Java 7 ForkJoinPool The common pool of ForkJoinPool threads are implicitly used in Java applications whenever ForkJoinTasks are submitted for execution without explicitly specifying a custom ForkJoinPool instance. Here are some scenarios in which the common pool threads are implicitly utilized: ForkJoinPool ForkJoinPool Parallel Stream Operations: When using parallel stream operations in Java 8 or later, such as parallel() or parallelStream(), the underlying implementation may utilize the common pool threads for parallel execution of stream operations. For example:
javaCopy codeList<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.parallelStream().mapToInt(Integer::intValue).sum(); RecursiveTask and RecursiveAction: If you create instances of RecursiveTask or RecursiveAction and invoke their fork() and join() methods, the tasks are typically executed using the common pool threads. For example:
javaCopy codeclass MyRecursiveTask extends RecursiveTask<Integer> {
    @Override
    protected Integer compute() {
        // Task logic here
    }
}
MyRecursiveTask task = new MyRecursiveTask();
int result = ForkJoinPool.commonPool().invoke(task); Task Execution by ForkJoinPool: Any ForkJoinTasks submitted to the ForkJoinPool using methods like invoke(), submit(), or execute() without specifying a custom pool instance will be executed using the common pool threads. Parallel Array Operations: Operations on parallel arrays using Arrays.parallelSetAll(), Arrays.parallelSort(), etc., may utilize the common pool threads for parallel processing. CompletableFuture: Operations on CompletableFuture, especially those involving asynchronous computations and combining results using methods like thenCombine() or thenApplyAsync(), may leverage the common pool threads for execution. Parallel Stream Operations: When using parallel stream operations in Java 8 or later, such as parallel() or parallelStream(), the underlying implementation may utilize the common pool threads for parallel execution of stream operations. For example: javaCopy codeList<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.parallelStream().mapToInt(Integer::intValue).sum(); Parallel Stream Operations : When using parallel stream operations in Java 8 or later, such as parallel() or parallelStream() , the underlying implementation may utilize the common pool threads for parallel execution of stream operations. For example: Parallel Stream Operations parallel() parallelStream() javaCopy codeList<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.parallelStream().mapToInt(Integer::intValue).sum(); javaCopy codeList<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.parallelStream().mapToInt(Integer::intValue).sum(); RecursiveTask and RecursiveAction: If you create instances of RecursiveTask or RecursiveAction and invoke their fork() and join() methods, the tasks are typically executed using the common pool threads. For example: javaCopy codeclass MyRecursiveTask extends RecursiveTask<Integer> {
    @Override
    protected Integer compute() {
        // Task logic here
    }
}
MyRecursiveTask task = new MyRecursiveTask();
int result = ForkJoinPool.commonPool().invoke(task); RecursiveTask and RecursiveAction : If you create instances of RecursiveTask or RecursiveAction and invoke their fork() and join() methods, the tasks are typically executed using the common pool threads. For example: RecursiveTask and RecursiveAction RecursiveTask RecursiveAction fork() join() javaCopy codeclass MyRecursiveTask extends RecursiveTask<Integer> {
    @Override
    protected Integer compute() {
        // Task logic here
    }
}
MyRecursiveTask task = new MyRecursiveTask();
int result = ForkJoinPool.commonPool().invoke(task); javaCopy codeclass MyRecursiveTask extends RecursiveTask<Integer> {
    @Override
    protected Integer compute() {
        // Task logic here
    }
}
MyRecursiveTask task = new MyRecursiveTask();
int result = ForkJoinPool.commonPool().invoke(task); Task Execution by ForkJoinPool: Any ForkJoinTasks submitted to the ForkJoinPool using methods like invoke(), submit(), or execute() without specifying a custom pool instance will be executed using the common pool threads. Task Execution by ForkJoinPool : Any ForkJoinTasks submitted to the ForkJoinPool using methods like invoke() , submit() , or execute() without specifying a custom pool instance will be executed using the common pool threads. Task Execution by ForkJoinPool ForkJoinPool invoke() submit() execute() Parallel Array Operations: Operations on parallel arrays using Arrays.parallelSetAll(), Arrays.parallelSort(), etc., may utilize the common pool threads for parallel processing. Parallel Array Operations : Operations on parallel arrays using Arrays.parallelSetAll() , Arrays.parallelSort() , etc., may utilize the common pool threads for parallel processing. Parallel Array Operations Arrays.parallelSetAll() Arrays.parallelSort() CompletableFuture: Operations on CompletableFuture, especially those involving asynchronous computations and combining results using methods like thenCombine() or thenApplyAsync(), may leverage the common pool threads for execution. CompletableFuture : Operations on CompletableFuture , especially those involving asynchronous computations and combining results using methods like thenCombine() or thenApplyAsync() , may leverage the common pool threads for execution. CompletableFuture CompletableFuture thenCombine() thenApplyAsync() In all these scenarios, the common pool threads are implicitly used by the Java runtime to execute tasks in parallel, taking advantage of multi-core processors and maximizing CPU utilization. Generally, it’s not advisable to use ForkJoinPool threads directly in the methods of CompletableFuture . Here's why: ForkJoinPool CompletableFuture Reasons to Avoid Direct Usage: Reasons to Avoid Direct Usage: Conflicting Execution Models: CompletableFuture uses its own asynchronous execution mechanism, often relying on a cached thread pool or a custom executor you provide. Bypassing this mechanism and introducing ForkJoinPool threads can lead to unexpected behavior and potential thread pool management issues. Limited Control: Using thenAsync allows CompletableFuture to manage thread pool utilization based on the workload. Direct ForkJoinPool usage might not align with this management strategy. Blocking: ForkJoinPool is optimized for CPU-bound tasks with coarse-grained parallelism. Blocking operations within thenAsync tasks can hinder the pool's efficiency. Conflicting Execution Models: CompletableFuture uses its own asynchronous execution mechanism, often relying on a cached thread pool or a custom executor you provide. Bypassing this mechanism and introducing ForkJoinPool threads can lead to unexpected behavior and potential thread pool management issues. Conflicting Execution Models: CompletableFuture ForkJoinPool Limited Control: Using thenAsync allows CompletableFuture to manage thread pool utilization based on the workload. Direct ForkJoinPool usage might not align with this management strategy. Limited Control: thenAsync CompletableFuture ForkJoinPool Blocking: ForkJoinPool is optimized for CPU-bound tasks with coarse-grained parallelism. Blocking operations within thenAsync tasks can hinder the pool's efficiency. Blocking: ForkJoinPool thenAsync Recommended Approach: Recommended Approach: Leverage the internal asynchronous execution mechanism of CompletableFuture. You can configure a custom executor for CompletableFuture if you have specific thread pool requirements, but it's usually not necessary for basic asynchronous tasks. If you have CPU-bound tasks suitable for ForkJoinPool, consider processing them before using CompletableFuture. Utilize CompletableFuture for the asynchronous chaining of these pre-processed results. Leverage the internal asynchronous execution mechanism of CompletableFuture . You can configure a custom executor for CompletableFuture if you have specific thread pool requirements, but it's usually not necessary for basic asynchronous tasks. CompletableFuture CompletableFuture If you have CPU-bound tasks suitable for ForkJoinPool , consider processing them before using CompletableFuture . Utilize CompletableFuture for the asynchronous chaining of these pre-processed results. ForkJoinPool CompletableFuture CompletableFuture In summary, exercise caution while using CompletableFuture methods without passing custom executor service as it might create some unexpected behavior.

When is Common ForkJoinPool Used Internally by JVM?

A Pivotal Moment in AI : Leaders Rally for a Natural AI Initiative

A common trade-off in most dynamic websites is, well they are dynamic; meaning every time a user refreshes or requests a page, the web server makes all sorts of calculations, before generating the final response — from database logic to template rendering to business logic; basically creating a page every time the user requests it. This approach is a lot more expensive in terms of resources than your standard static websites or even Generated Static Sites. For most small to medium-scale websites this isn’t a major issue, but if you want to scale your website to the next level, you need to cut as much overhead as you can. That’s where caching comes in. To cache something means to save the result of an expensive calculation so that you don’t have to perform the calculation next time. Here’s some pseudocode explaining how this would work for a dynamically generated web page: if page exists in cache:
  return cache[page.title]

else:
  generate page
  cache[page.title] = page # for next time 
  return generated page Django comes with a robust cache system that lets you save dynamic pages so they don’t have to be calculated for each request. For convenience, Django offers different levels of cache granularity: You can cache the output of specific views, you can cache only the pieces that are difficult to produce, or you can cache your entire site. Prerequisites To follow this article, you need to have knowledge about the following: Prior experience working with Django & Python(Beginner to intermediate) Django≥2.2.6 Python≥3.4 Setting up the caching system There are different ways in which caching can be set up, depending on where you want your cache to be stored. The ways in which you can set up caching in your Django application are discussed in the following sections. Memcached is an entirely memory-based cache server, originally developed to handle high loads at LiveJournal.com and subsequently open-sourced by Danga Interactive. It is used by sites such as Facebook and Wikipedia to reduce database access and dramatically increase site performance. Memcached After installing Memcached itself, you’ll need to install a Memcached binding. There are several Python Memcached bindings available; the two supported by Django are and . pylibmc pymemcache To use Memcached with Django: Set to or (depending on your chosen memcached binding) BACKEND django.core.cache.backends.memcached.PyMemcacheCache django.core.cache.backends.memcached.PyLibMCCache Set to values, where is the IP address of the Memcached daemon and is the port on which Memcached is running, or to a value, where is the path to a Memcached Unix socket file. LOCATION ip:port ip port unix:path path # using pymemcache binding
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.PyMemcacheCache',
        'LOCATION': '127.0.0.1:11211',
    }
} One excellent feature of Memcached is its ability to share a cache over multiple servers. This means you can run Memcached daemons on multiple machines, and the program will treat the group of machines as a cache, without the need to duplicate cache values on each machine. single To take advantage of this feature, include all server addresses in , either as a semicolon or comma-delimited string or as a list. LOCATION In this example, the cache is shared over Memcached instances running on IP addresses 172.19.26.240 and 172.19.26.242, both on port 11211: CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.PyMemcacheCache',
        'LOCATION': [
            '172.19.26.240:11211',
            '172.19.26.242:11211',
        ]
    }
} A final point about Memcached is that memory-based caching has a disadvantage: because the cached data is stored in memory, the data will be lost if your server crashes. Clearly, memory isn’t intended for permanent data storage, so don’t rely on memory-based caching as your only data storage. Without a doubt, of the Django caching backends should be used for permanent storage – they’re all intended to be solutions for caching, not storage – but we point this out here because memory-based caching is particularly temporary. none Database Caching Django can store its cached data in your database. This works best if you’ve got a fast, well-indexed database server. To use a database table as your cache backend: Set to BACKEND django.core.cache.backends.db.DatabaseCache Set to , the name of the database table. This name can be whatever you want, as long as it’s a valid table name that’s not already being used in your database. LOCATION tablename In this example, the cache table’s name is my_cache_table CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
        'LOCATION': 'my_cache_table',
    }
} Unlike other cache backends, the database cache does not support the automatic culling of expired entries at the database level. Instead, expired cache entries are culled each time , , or is called. add() set() touch() Creating the cache table Before using the database cache, you must create the cache table with this command: python manage.py createcachetable Filesystem Caching The file-based backend serializes and stores each cache value as a separate file. To use this backend set to and to a suitable directory. For example, to store cached data in, , use this setting: BACKEND "django.core.cache.backends.filebased.FileBasedCache" LOCATION /var/tmp/django_cache CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
        'LOCATION': '/var/tmp/django_cache', # C:/Foo/Bar if in windows system
    }
} Make sure the directory pointed to by this setting either exists and is readable and writable, or that it can be created by the system user under which your web server runs. Continuing the above example, if your server runs as the user , make sure the directory exists and is readable and writable by the user , or that it can be created by the user . apache /var/tmp/django_cache apache apache Local-memory caching This is the default cache if another is not specified in your settings file. If you want the speed advantages of in-memory caching but don’t have the capability of running Memcached, consider the local-memory cache backend. This cache is per-process (see below) and thread-safe. To use it, set to . For example: BACKEND "django.core.cache.backends.locmem.LocMemCache" CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
        'LOCATION': 'unique-name',
    }
} The cache is used to identify individual memory stores. If you only have one cache, you can omit the ; however, if you have more than one local memory cache, you will need to assign a name to at least one of them in order to keep them separate. LOCATION locmem LOCATION The cache uses a least-recently-used (LRU) culling strategy. Note that each process will have its own private cache instance, which means no cross-process caching is possible. This also means the local memory cache isn’t particularly memory-efficient, so it’s probably not a good choice for production environments. It’s nice for development. The per-site cache Once the cache is set up, the simplest way to use caching is to cache your entire site. You’ll need to add and to your setting, as in this example: 'django.middleware.cache.UpdateCacheMiddleware' 'django.middleware.cache.FetchFromCacheMiddleware' MIDDLEWARE MIDDLEWARE = [
    'django.middleware.cache.UpdateCacheMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.cache.FetchFromCacheMiddleware',
] caches GET and HEAD responses with status 200, where the request and response headers allow. Responses to requests for the same URL with different query parameters are considered to be unique pages and are cached separately. This middleware expects that a HEAD request is answered with the same response headers as the corresponding GET request; in which case it can return a cached GET response for the HEAD request. FetchFromCacheMiddleware Additionally, automatically sets a few headers in each which affect downstream caches: UpdateCacheMiddleware HttpResponse Sets the header to the current date/time plus the defined CACHE_MIDDLEWARE_SECONDS. Expires Sets the header to give a max-age for the page – again, from the CACHE_MIDDLEWARE_SECONDS setting. Cache-Control The per-view cache A more granular way to use the caching framework is by caching the output of individual views. defines a decorator that will automatically cache the view’s response for you: django.views.decorators.cache cache_page from django.views.decorators.cache import cache_page

@cache_page(60 * 15)
def my_view(request):
    ... takes a single argument: the cache timeout, in seconds. In the above example, the result of the view will be cached for 15 minutes. (Note that we’ve written it as for the purpose of readability. will be evaluated to – that is, 15 minutes multiplied by 60 seconds per minute.) cache_page my_view() 60 * 15 60 * 15 900 The cache timeout set by takes precedence over the directive from the header. cache_page max-age Cache-Control The per-view cache, like the per-site cache, is keyed off of the URL. If multiple URLs point at the same view, each URL will be cached separately. Continuing the example, if your URLconf looks like this: my_view urlpatterns = [
    path('foo/<int:code>/', my_view),
] then requests to and will be cached separately, as you may expect. But once a particular URL (e.g., ) has been requested, subsequent requests to that URL will use the cache. /foo/1/ /foo/23/ /foo/23/ By default, the cache will be used, but you can specify any cache you want: default @cache_page(60 * 15, cache="other_cache")
def my_view(request):
    ... You can also use specify per-view cache in the URL configurations from django.views.decorators.cache import cache_page

urlpatterns = [
    path('foo/<int:code>/', cache_page(60 * 15)(my_view)),
] Template Fragment Caching Template fragment caching gives you the most control over what gets cached on your site. Template fragment caching enables you to cache specific parts of your template where huge calculations are done. We can do this with the cache template tag, . {% cache %} The template tag caches the contents of the block for a given amount of time. It takes at least two arguments: the cache timeout, in seconds, and the name to give the cache fragment. The fragment is cached forever if timeout is . The name will be taken as is, do not use a variable. For example: {% cache %} None {% load cache %}
{% cache 500 sidebar %}
    .. sidebar ..
{% endcache %} Sometimes you might want to cache multiple copies of a fragment depending on some dynamic data that appears inside the fragment. For example, you might want a separate cached copy of the sidebar used in the previous example for every user of your site. Do this by passing one or more additional arguments, which may be variables with or without filters, to the template tag to uniquely identify the cache fragment: {% cache %} {% load cache %}
{% cache 500 sidebar request.user.username %}
    .. sidebar for logged in user ..
{% endcache %} The Low-Level Cache API Sometimes, caching an entire rendered page doesn’t gain you very much and is, in fact, inconvenient overkill. Perhaps your site includes a view whose results depend on many expensive queries, the results of which change frequently, caching these parts with per-view caching or per-site caching is not ideal, but you would still like to cache some parts of view that rarely change. For cases, like these, django provides a low-level API. You can use this API to store any in python to your cache. You can cache picklable objects Accessing the Cache API You can access the caches configured in the setting through a dict-like object: . Repeated requests for the same alias in the same thread will return the same object. As a shortcut, the default cache is available as : CACHES django.core.cache.caches django.core.cache.cache >>> from django.core.cache import cache Example: from django.shortcuts import render
from .models import Posts
from django.core.cache import cache

def cache_recipes_view(request):
    latest_posts = cache.get('latest_posts')
    if latest_posts is None:
        latest_posts = Posts.objects.all().order_by("-updated_at")[:5]
        cache.set('recipes', latest_posts)

    return render(request, 'blog/latest_posts.html', {
        'posts': latest_posts
    }) : Common Methods - Set value to any picklable python object with given key. cache.set(”key”, value) - Retrieve the value of key from cache cache.get(”key”) : Get value if exists as set value passed in as parameter for timeout of 100 seconds. cache.get_or_set(”key”, value_if_not_present, 100) : Eg: cache.get_many([’name’, ‘age’, ‘job_title’]) - Return multiple values as dictionary. cache.get_many(list_of_keys) : Eg: cache.set_many({”name”:”Dev”, “age”:18}, 100) cache.set_many(dictionary_object, timeout) - Delete an object from cache memory. cache.delete(key) - Clears whole cache memory. cache.clear() - Set new timeout for given key. cache.touch(key,timeout) - Increment the key(only for integers), by value delta. Default 1 if none is specified cache.incr(key, delta=1) - Decrement the key, value delta. Default 1 if none is specified. cache.decr(key, delta=1) Conclusion This article's aim was to take you from not knowing anything about caching in Django applications to showing you the different ways in which you can cache data when building Django applications. Hopefully, I was successful. With this article, you can add caching to any part of your application. It's not advisable to cache the entire site unless you have excess memory and don't care about cutting costs. Try to make a calculated decision when picking portions of your site to cache. Now that you have learned all this, hopefully, you will confidently implement the knowledge in your future Django projects or when it is expected by the company you work for. Also published . here

Caching in Django: Everything You Need to Know

In this article, I will show you how to use the , which hasn’t received significant dissemination among Java developers. ForkJoinPool is one of the ’s implementations. It is used in and Stream API. It was designed to simplify parallelism for recursive tasks by breaking the single task into independent ones until they are small enough to be executed asynchronously. With this class, you can perform a significantly large amount of tasks in a small number of threads. ForkJoinPool ExecutorService CompletableFuture Java has a common implementation that can be created through the static method: ForkJoinPool commonPool() ForkJoinPool forkJoinPool = ForkJoinPool.commonPool(); ForkJoinTask has its own and implementations. These implementations are called and respectively. Each of them has an abstract method, which must be implemented during implementation. returns generic <T> value, returns void. Both of these implementations are inherited from the abstract class. ForkJoinTask Runnable Callable RecursiveAction RecursiveTask compute() RecursiveTask<T>#compute() RecursiveAction#compute() ForkJoinTask To start a task in , use the method : ForkJoinPool T invoke(ForkJoinTask<T> task) ForkJoinTask forkJoinTask = new ForkJoinTaskImpl(...);
forkJoinPool.invoke(forkJoinTask); In addition to the method, has the following methods: and . In terms of usage, the is similar to the . But in the case of a fork-join, the thread may not actually fall asleep, it will rather switch to another task. This strategy is called “work stealing”, it allows more efficient use of a limited number of threads. compute() ForkJoinTask fork() join() ForkJoinTask#join() Thread#join() Fibonacci example Let's look at the simple example of the implementation for calculating the Fibonacci numbers: ForkJoinTask public class FibonacciTask extends RecursiveTask<Integer> {
    private final int n;

    public FibonacciTask(int n) {
        this.n = n;
    }

    @Override
    public Integer compute() {
        if (n < 2) return n;
        FibonacciTask f1 = new FibonacciTask(n - 1);
        FibonacciTask f2 = new FibonacciTask(n - 2);
        f1.fork();
        return f2.compute() + f1.join();
    }
} In this example, implements the method, which creates additional instances and forks them. The method asks the current thread to wait until results are returned by the forked methods. FibonacciTask compute() FibonacciTask join() Merge Sort Let's take a look at the more complex example of - the Merge Sort. It is based on the "Divide and Conquer" principle, old as the world. We need to divide source problems into subtasks, solve them recursively and combine the results: ForkJoinTask For this task we will use as the implementation, since we don't need a return value. We will add as a parameter to the constructor and instantiate the class's field: RecursiveAction ForkJoinTask int[] arr public class MergeSortAction extends RecursiveAction {

    private final int[] arr;

    public MergeSortAction(int[] arr) {
        this.arr = arr;
    }

    @Override
    public void compute() {
        ...
    }

    private void merge(int[] left, int[] right) {
        ...
    }

} Next, we implement the method. It will accept 2 arrays - and parts. We need to merge these unsorted arrays by comparing elements and assigning the smallest element to the appropriate arr index. When one of the arrays will be empty, the loop will break, but the data from another non-empty array part still needs to be merged. To do this we have two additional while loops to get all the data from both arrays: merge() left right while private void merge(int[] left, int[] right) {
    int i = 0, j = 0, k = 0;
    while (i < left.length && j < right.length) {
        if (left[i] < right[j])
            arr[k++] = left[i++];
        else
            arr[k++] = right[j++];
    }
    while (i < left.length) {
        arr[k++] = left[i++];
    }
    while (j < right.length) {
        arr[k++] = right[j++];
    }
} Next, we will write the method to recursively divide the original array and pass the results to the method. To do this we need to calculate the middle index of the array. Then we divide the original array into two parts: and . To fill them we copy original data by calling : compute() merge() left right System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length) @Override
public void compute() {
    if (arr.length < 2) return;
    int mid = arr.length / 2;

    int[] left = new int[mid];
    System.arraycopy(arr, 0, left, 0, mid);

    int[] right = new int[arr.length - mid];
    System.arraycopy(arr, mid, right, 0, arr.length - mid);

    ...
} Now, we have two separate arrays. Let’s divide them recursively by creating new tasks and run them asynchronously by passing them into method. To sort and combine two arrays we use method: MergeSortAction invokeAll() merge() @Override
public void compute() {
    if (arr.length < 2) return;
    int mid = arr.length / 2;

    int[] left = new int[mid];
    System.arraycopy(arr, 0, left, 0, mid);

    int[] right = new int[arr.length - mid];
    System.arraycopy(arr, mid, right, 0, arr.length - mid);

    invokeAll(new MergeSortAction(left), new MergeSortAction(right));
    merge(left, right);
} Speed testing We’ve finished our parallel Merge Sort. Let’s test it and compare performance with the non-parallel version. I used to generate random numbers and to calculate the execution time: ThreadLocalRandom ZonedDateTime class MergeSortTest {

    private final List<MergeSort> mergeSortImpls = 
            Arrays.asList(new MergeSortImpl(), new ParallelMergeSortImpl());

    @Test
    void sort() {
        for (MergeSort mergeSort : mergeSortImpls) {
            int[] arr = IntStream
                    .range(0, 100_000_000)
                    .map(i -> ThreadLocalRandom.current().nextInt())
                    .toArray();
            ZonedDateTime now = ZonedDateTime.now();
            mergeSort.sort(arr);
            System.out.printf("%s exec time: %dms\n",
                    mergeSort.getClass().getSimpleName(),
                    ChronoUnit.MILLIS.between(now, ZonedDateTime.now()));
            assertTrue(isSorted(arr));
        }
    }

    private boolean isSorted(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            if (arr[i] > arr[i + 1])
                return false;
        }
        return true;
    }

} There are the execution results for 100 million of numbers on 8-core CPU: Conclusion In this article, I showed you an example of how to use Fork/Join Framework. I hope you now have a basic idea of how to speed up your applications. The source code is available . over on GitHub

Parallel Merge Sort with Fork/Join Framework

Over the past years of web development I have stumbled upon the FeathersJS project and have really loved it so far. It offers a lot of functionality out of the box like websockets and authentication which makes it a great alternative to real-time backends like Firebase at a fraction of the cost. There are very little node frameworks that do so much, so well with so little configuration and the only thing I see wrong with it is that it isn’t more widely used, so let me start off with why you should use FeathersJS as your API backend framework. Scaffolding your application with feathers-cli gives you websockets out of the box with a single line of code.Add authentication with a second line of code including all the public’s favorites like Facebook, Google and GitHub.A third line of code connects to almost every single database on the planet. For example MongoDB or all SQL databases.Killer integration with Vue and React for real-time updates to your frontend finishes the deal. With that sales pitch out of the way, wanting to move from prototyping to an actual production scenario, I recently had the requirement to start sending verification emails. There seems to be a module for that named feathers-authentication-management. Going through the documentation for this library was challenging as there is a lot to process at once. There is a , but it seems based on an older version of feathers and has a lot of external dependencies like Pug, Lodash, Mongoose etc. This article is an attempt to write down how to get verification emails working based on the newest version of FeathersJS v3 and without any other dependencies. tutorial and a repo from Jon Paul Miles The goal of this tutorial is to have a clean feathers app that is able to handle user account creation requests via REST, send the user a validation link and handle the clicking of that link in the simplest way possible. We will implement this one action leaving other actions like password reset, or account changes, for you to implement. This tutorial will assume that you already have some knowledge of how to use the core of the feathers framework and general web development practices. All code in this article will be available in the repo: https://github.com/ImreC/feathers-verification-emails How it all works What we are going to create is a flow to have the user verify their email address. This goes as follows: The user creates an account on the feathers appThe server adds a field isVerified to the user object in the database and sets it to falseThe server creates a verification token for the userThe user gets sent an email containing a client link with the token as a parameterThe user clicks the link and on visiting the client this token gets sent back to the serverThe server sets the isVerified field on the user object to trueThe user gets all the superpowers from your awesome application So roughly we need to do the following things to get this to work. We need to generate a feathers applicationWe need to create something to send emailsWe need to install the authentication-management package to generate the token and handle the extra fields on the user objectWe need to create hooks to get it all to work togetherWe need to code a simple client to handle the clicked linksWe need to secure some parts of the users service to make sure users communicate via the new authentication management route So let’s get started. Step 1: Generating a FeathersJS app To generate our feathers app we will use the feathers-cli package. As a transport we will stick to simple REST because we don’t really need anything else for now. We only need a local authentication strategy and we are going to use NeDB as a database for simplicity. We can generate all this with the following lines of code npm install feathers-cli -g
feathers generate app
feathers generate authentication We can now create our test user by sending a post request to the users table. That’s it, we already have a working app with the possibility to create users and perform authentication. This is what makes FeathersJS awesome. Step 2: Setting up our mailer service If we are going to send emails to our users we need some way to actually send email to them. Therefore, we need to create a service to send emails from. Unfortunately, at the time of writing this is not possible from feathers-cli. Therefore, we are going to generate a custom service called mailer on the /mailer route. feathers service generate This will give us a mailer folder in the services folder which will contain three files, namely mailer.class.js, mailer.hooks.js and mailer.service.js. Since we are not going to use all the methods of this route but only use it for mailing people we can delete the class file. We then need to install the feathers-mailer and the nodemailer-smtp-transport package. install feathers-mailer nodemailer-smtp-trans npm port --save I am using Amazon SES to send emails, but any account accepting smtp will do. Jon Paul Miles uses gmail and that also works perfectly fine. To do it with gmail check out . Update the mailer.service.js file to look like this. his article Then all configuration is done and you can test your new /mailer route by sending a POST request to /mailer with this as body: hooks = ( ); Mailer = ( ); smtpTransport = ( ); .exports = {
  app.use( , Mailer(smtpTransport({ : , : , : { : process.env.SMTP_USER, : process.env.SMTP_PASS
    }
  }))); service = app.service( );
  service.hooks(hooks);
}; // Initializes the `/mailer` service on path `/mailer` const require './mailer.hooks' const require 'feathers-mailer' const require 'nodemailer-smtp-transport' module ( ) function app '/mailer' host 'email-smtp.us-east-1.amazonaws.com' secure true auth user pass const 'mailer' Github Gist NOTE: both “from” and “to ” emails need to be verified in Amazon SES for this to work. Check out SES sandbox mode for more details. Obviously we do not want our mailer to be misused for spam or something, so after testing we are going to close it off by adding a before hook on the all mailer routes. For this we install the feathers-hooks-common package. npm install feathers-hooks- -- common save And add the following code to mailers.hooks.js. { disallow } = (‘feathers-hooks-common’); .exports = { : { : [
 disallow(‘external’)
 ],
... const require module before all You can test this by re-sending you POST request to see that it now fails, making the mailer for your use only. Now that we have a simple service that can send email it is time to go to the next step. Setting up authentication management. Step 3: Setting up the feathers-authentication-management module Now we are going to set up the feathers-authentication-management module. First let’s install it. npm feathers- - install authentication management --save Then we are going to generate a custom service with named . We can leave the authentication for now because we are going to do something with that manually later. Also, we can delete the class file from our service again. feathers generate service authmanagement Then we are going to create a notifier.js file in the /authmanagement folder. This file consists of three parts. The getLink function which generates our token url. This can either have a verify token or a reset token included. For now, we are only using the verify token. The sendEmail function which calls our /mailer service internally to send the email. The notifier function which, based on the action type, decides what email to send where. We are now only using the verification part but this can also be used to code the other actions. Also, we will only be sending the plain link to the email. If you want to use html templates or some preprocessor to generate nicer looking emails, you need to make sure they are inserted as a value in the html key in the email object. s .exports = { { url = + type + + hash url
  } { app.service( ).create(email).then( { .log( , result)
    }).catch( { .log( , err)
    })
  } { : { tokenLink email (type) { : tokenLink = getLink( , user.verifyToken)
          email = { : process.env.FROM_EMAIL, : user.email, : , : tokenLink
          } sendEmail(email) : tokenLink = getLink( , user.verifyToken)
          email = { : process.env.FROM_EMAIL, : user.email, : , : } sendEmail(email) :
          tokenLink = getLink( , user.resetToken)
          email = {} sendEmail(email) :
          tokenLink = getLink( , user.resetToken)
          email = {} sendEmail(email) :
          email = {} sendEmail(email) :
          tokenLink = getLink( , user.verifyToken)
          email = {} sendEmail(email) : }
    }
  }
} module ( ) function app ( ) function getLink type, hash const 'http://localhost:3030/' '?token=' return ( ) function sendEmail email return 'mailer' ( ) function result console 'Sent email' => err console 'Error sending email' return notifier ( ) function type, user, notifierOptions let let switch case 'resendVerifySignup' //sending the user the verification email 'verify' from to subject 'Verify Signup' html return break case 'verifySignup' // confirming verification 'verify' from to subject 'Confirm Signup' html 'Thanks for verifying your email' return break case 'sendResetPwd' 'reset' return break case 'resetPwd' 'reset' return break case 'passwordChange' return break case 'identityChange' 'verifyChanges' return break default break Github Gist Now all we need to do is set up our authmanagement service to use this notifier function. That looks something like this: authManagement = ( ); hooks = ( ); notifier = ( ); .exports = { app.configure(authManagement(notifier(app))); service = app.service( );

  service.hooks(hooks);
}; // Initializes the `authmanagement` service on path `/authmanagement` const require 'feathers-authentication-management' const require './authmanagement.hooks' const require './notifier' module ( ) function app // Initialize our service with any options it requires // Get our initialized service so that we can register hooks and filters const 'authManagement' Github Gist That’s it, we are now ready to set up our hooks to tie it all together. Step 4: Setting up authentication management hooks Now we are ready to set up some hooks to actually get our service to work. For this we need to adapt the file. We need to do a couple of things here. users.hooks.js Import the verification hooks from feathers authentication management by adding this line to the top: const verifyHooks = require(‘feathers-authentication-management’).hooks; Import our notifier by adding this line: const accountService = require(‘../authmanagement/notifier’); Then add to the before create hook to add verification to our user object. This needs to be after the hook. What this code does is that it adds some extra fields to our user objects and generates a token. verifyHooks.addVerification() hashPassword() NOTE: If you use any ORMs like Mongoose or Sequelize you need to add the verification fields manually to the user model. These need to be the following fields. isVerified: { type: Boolean }, verifyToken: { type: String }, verifyExpires: { type: Date }, verifyChanges: { type: Object }, resetToken: { type: String }, resetExpires: { type: Date } Finally, we need to add two after create hooks to our user model. One to call our notifier function and one to remove the verification again. That looks like this: after: { : [ {
        accountService(context.app).notifier( , context.result)
      },
      verifyHooks.removeVerification()
    ] create => context 'resendVerifySignup' Giving us the total result: { authenticate } = ( ).hooks; verifyHooks = ( ).hooks; accountService = ( ); {
  hashPassword, protect
} = ( ).hooks; .exports = { : { : [], : [ authenticate( ) ], : [ authenticate( ) ], : [
      hashPassword(),
      verifyHooks.addVerification()
    ], : [ hashPassword(),  authenticate( ) ], : [ hashPassword(),  authenticate( ) ], : [ authenticate( ) ]
  }, : { : [ protect( )
    ], : [], : [], : [ {
        accountService(context.app).notifier( , context.result)
      },
      verifyHooks.removeVerification()
    ], : [], : [], : []
  }, : { : [], : [], : [], : [], : [], : [], : []
  }
}; const require '@feathersjs/authentication' const require 'feathers-authentication-management' const require '../authmanagement/notifier' const require '@feathersjs/authentication-local' module before all find 'jwt' get 'jwt' create update 'jwt' patch 'jwt' remove 'jwt' after all // Make sure the password field is never sent to the client // Always must be the last hook 'password' find get create => context 'resendVerifySignup' update patch remove error all find get create update patch remove Github Gist Now it’s time for the big test. If you finished all this and set up your mailer correctly, you can send a POST request to the user service to create an account. On doing this, the email should be sent to your email address with a verification link inside. If that works, well done! Now all we need to do is create a client page to handle the click. Step 5: Verifying the email link For simplicity we will create a basic html page with a XMLHttpRequest() script to handle the verification. Obviously there are better way to handle this with feathers-client and your favorite frontend library. However, that is out of scope of this article. Following the structure of our verification link we will create a new folder in the /public folder of our app called “verify”. Here we will put a new index.html file. All this needs to do is to send a POST request to our /authmanagement service with the following JSON object. {
    “action”:”verifySignupLong”,
    ”value”: YOUR_TOKEN
} So in the end all we need to do is create a script that takes the token parameter from the URL and posts this to our endpoint. For this I have created a sample page which looks like this. <html> <p id = "info">
    Sending token
  </p> <script>
    var url = new URL(window.location.href);
    var token = url.searchParams.get("token");
    var obj = {
      action: 'verifySignupLong',
      value: token
    }
    console.log(JSON.stringify(obj))
    console.log(obj)
    var xhttp = new XMLHttpRequest();
    xhttp.onreadystatechange = function() {
        if (this.readyState == 4 && this.status == 201) {
           // Typical action to be performed when the document is ready:
           document.getElementById("info").innerHTML = 'Verification Successful for action <b>' + obj.action + '</b> and token <b>' + obj.value + '</b>';
        } else {
          document.getElementById("info").innerHTML = xhttp.response
        }
    };
    xhttp.open('POST', 'http://localhost:3030/authmanagement' , true);
    xhttp.setRequestHeader('Content-Type', 'application/json');
    xhttp.send(JSON.stringify(obj));
  </script> < < > body </ > body /html> Github Gist If you have implemented this, the full flow should work. You can test this by clicking on the link you sent yourself earlier and checking that the page shows a successful token sent. This should trigger a second email thanking you for verification. Step 6: Securing the application Now that the app works there is only one step to complete and that is adding some security to the users service. Since we have a nice authentication flow running we don’t want any users to meddle with the user service directly anymore. For this we create two before hooks. One on the update method and one on the patch method. With the one on the update method we are going to disallow this method in its entirety. After all, we wouldn’t want someone to be able to replace our carefully verified user by a new one. The one on the patch method we want to restrict the user from touching any of the authentication field methods directly. To do this we update the user before hooks to: before: { : [], : [ authenticate( ) ], : [ authenticate( ) ], : [
      hashPassword(),
      verifyHooks.addVerification()
    ], : [
      commonHooks.disallow( )
    ], : [
      commonHooks.iff(
        commonHooks.isProvider( ),
          commonHooks.preventChanges( , , , , , , , , ),
          hashPassword(),
          authenticate( )
        )
    ], : [ authenticate( ) ]
  } all find 'jwt' get 'jwt' create update 'external' patch 'external' 'email' 'isVerified' 'verifyToken' 'verifyShortToken' 'verifyExpires' 'verifyChanges' 'resetToken' 'resetShortToken' 'resetExpires' 'jwt' remove 'jwt' Github Gist NOTE: authentication-management has password hashing built in. To prevent double hashing our password we are only hashing it for external calls. Next Steps There are a lot more things to set up after this and a lot more optimizations to make. You can start by adding fancy email templates instead of the link. Another possibility would be to replace the email transport by something else, for example a short verification token via SMS. Or start adding code for any of the other actions that are covered by feathers-authentication-management. To help you on that please refer to: The article by Jon Paul Miles . This covers the rest of the actions and gives more info on how to set up the rest. https://blog.feathersjs.com/how-to-setup-email-verification-in-feathersjs-72ce9882e744 The (outdated) documentation . https://auk.docs.feathersjs.com/api/authentication/local-management.html Thanks for reading and happy coding!

Setting up email verification in FeathersJS

I have been working with C#’s TPL for a while now, and coming back to Java once in a while for Android or some web stuff always makes me hate every bit of it. Not the JVM part (In my opinion JVM is way better than CLR), but the writing part of it (not to say I have problems with C# here and there). The way threads and callbacks are implemented, and functions were not first class citizen until recently. Although Java 8 brings a lot to table, there are still problems that need to be addressed, one of them is Futures (or async/await or promises or deferred) and I strongly feel Kotlin even during it’s infancy is pulling off more than expected. In this blog post I am going to reason about why you need a better async programming model, a little bit of my history with Kotlin, and how Kotlin brings interesting stuff to table. All of this is my , and in no way says one promoting one technology over the other. I however will show you what has been done wrong in the past and how various technologies are inspiring from each other and adding something new to the paradigm. personal opinion Building the case using Android I am going to build my case using Android a typical developers nightmare. Quoting Swing or JavaFX might sound less relevant to most of developers, as a bigger audience out there is working on Android these days. If you have tried writing an Android application, doing back and forth transitions between main thread (aka UI thread) and background threads you know where am I gonna go with this. Just as a refresher I will quote ; you can find plethora of such tutorials and techniques advocated on StackOverflow and blogs. In a typical scenario for any kind of IO or compute intensive process you will launch a background thread, after completing you some how invoke a callback or method that ultimately runs rest of code on UI aka . this tutorial runOnUiThread But wait, there are libraries to write for such scenarios, libraries like , etc. “Why not use them?” one may ask. Well if you have been to the of UWP (Universal Windows Platform) and developed an application in C#, you might have tasted what I refer to as simplicity. The makes it a breeze to spin of large number of tasks, and controlling which one runs on what thread, or on what context will the execution resumes. There is obviously a learning curve, but once you get hold of it; you would mentally replace threads with tasks almost everywhere in your daily routine. Although the Android libraries advocate really good patterns but none compares to simplicity of invoking something like a function that runs on a background thread and return values to you like a normal function does. No callbacks, no event tracing, no stream of events, no tracking nothing. Dead simple function like invocations! This not only simplifies writing code but also makes debugging an easier job. Rather than guessing and searching annotations in code; you know where is the invoked code located, and how it resumes once invocation is completed. better code RxJava Otto dreaded land Task Parallel Library Let me put it this way, what would you prefer? A simple or (wait I have to use Otto and use multiple lines to show part of the problem): var user = await getUserInfo() // Somewhere in codebus = new Bus(ThreadEnforcer.MAIN);bus.register(this);...

// Somewhere else in code@Subscribepublic void onUserInfo(User u) {    Toast.makeText(this, this.getUserMessage(u), Toast.LENGTH_LONG).show();} ...

// In a galaxy far far away

    // carry the stupid bus around  
    this.`bus.post(user);`  
}  
... } This alone should be good enough to convince you about problem in your code. If it’s hard and scattered to explain in code, then it’s hard to debug. I can quote a similar example with RxJava. Again don’t get me wrong, , they totally have valid usages. One I can think of on top of my head right now is providing an update on UI when there is a push event from server. But it doesn't mean it’s perfect for every scenario, right? Another option could be . Which inspires it’s API almost directly from C# TPL. While it does provide you with , , or etc. there is still the tax of callbacks, and some initialization. I am not implying in any possible way Otto or RxJava are stupid duck tapes Bolt Framework continueWith onSuccess onSuccessTask Continuation Need for async/await Android’s workflow was just as an example, even at language level having asynchronous programming constructs, and then being able to multiplex it over a thread pool is critical. No matter if it’s HTTP server, or a DB engine; asynchronous paradigm has proved it’s ground over time. While Java 8 already has support for s the luxury of async/await gives it a certain intuitiveness that we all are familiar with. There is a reason why callback hells like Node.js is also moving towards async/await support, Python 3.6 did a really neat recently, and C# has TPL. CompletableFuture implementation My vague dates with Kotlin I tried Kotlin once or twice before trying to build an Android app. Kotlin was just getting started in those days. While I did enjoyed the really small runtime, interoperability, concise syntax, and cleaner less ceremonial approach with great comprehension. To be Android specific the ability to pass callbacks like and hook them up without parenthesis like a function body . It also allowed simpler data classes, function extensions, and a already supporting it. Happy but not satisfied, I was still looking for some sort of async/await support, and went back to my routine work using Kotlin where ever I can. If you are Android enthusiast and want to read more on why you should use Kotlin, there are may good out there. fun onClick(listener: () -> Unit) view.onClick { ... } extensive list of libraries reads Meet coroutines!!! With recent seems like my wish is almost fulfilled. Although the feature is experimental yet, but I don’t see it too far from being production ready, since I am able to fully express all the scenarios that I have seen practically during my app development experience. Just to try it out after I heard about the new release, I rewrote a service that Geolocates an IP and using coroutines. announcement of Kotlin 1.1 I go in tutorial mode about coroutines here as you can go find every thing you need on . For Android people there is a really good and few more already supporting Kotlin 1.1 coroutines. While working on the server code I observed few things about coroutines that I feel go beyond the usual async/await implementation (even beyond what C# does). They are not only a syntactic cleanup to what you might have been doing, but they also provide some powerful ways to express your code for complex scenarios. Lets go through few of them: won’t official documentation Kotlin coroutine article libraries Channels and select expression While C# TPL gives you the fundamental blocks for Tasks and inspires many of modern async implementations; the inter task communication has not been addressed really well. One might say you use or use techniques described . But like Golang, or Erlang where channels or mailboxes are first class citizens it’s much cleaner to express communication. Kotlin coroutines takes a page from above and comes with built-in channel support ( ). This lets you implement complicated patterns like , , or etc. Couple channels with the select expression and you can write complex dispatchers like: BufferBlock here documentation pipelines fan-out fan-in chatMessageProcessor(users: ReceiveChannel<IMessage>, system: ReceiveChannel<IMessage>, timeout: ReceiveChannel<IMessage>) { < > {users.onReceive { value ->  ... }system.onReceive { value ->  ... }timeout.onReceive { value ->  ... }}} suspend fun select Unit While this will sound familiar to many Golang folks, in JVM land it’s a really neat way to wait for one of multiple events and then act accordingly (I can already see some Akka fans pulling out their hair). This can let you spin off some coroutines that encapsulate some state and acts on them on some messages from environment. For example wait for a message from UI and then do updates to DB, or maybe make API calls to a server. Another example might be publishing chat messages to other coroutines that pushes a chat message to other users in same chat-room. Does this sound familiar? We are moving closer to Actors. Actors Actors are objects which encapsulate state and behavior, they communicate exclusively by exchanging messages which are placed into the recipient’s mailbox. — Akka Kotlin coroutines library comes with basic actors support, and awesome part is it’s syntactically clean as well; you don’t have to implement an interface, or define required methods for ceremonial purposes. It’s just like a go routine or an Erlang process, a simple function. Here is how simple it looks like: messageDeliveryActor() = actor<ChatMessage>( ) {// Do your stuff here...} fun CommonPool Like any other or it requires a context and that’s about it! Do keep in mind there are already mature libraries for Java that provide actor support. I am not undermining any of them! async run Transparent context switching So while writing the server I came across the typical problem of existing packages not supporting or utilizing the async APIs (No Java NIO, no netty, no nothing). The of Maxmind GeoIP2 library uses the object; Now calling any operation that reads from File would have blocked the thread in my thread pool. While one solution is to do a an async implementation myself, that is not always feasible. Call me a slacker the solution that I used was to have a thread pool for these kind of blocking operations, and have my IO coroutine bound only to that context. That way I will never block my request handling threads. Here is structure of what internals of my lookup class may look like: DatabaseReader File findContext = newFixedThreadPoolContext(4) suspend private fun find(ip: String): CityInfo? = run(findContext) {// Do the blocking thread blocking lookups here} Invoking this subroutine from my request is really transparent. In my case I am using and it supports async via . So my code for invoking find looks like this: jooby Deferred **fun** getGeoInfo()= Deferred { req, def ->  
        launch (CommonPool) {  
            ...  
            **val** ip = req.param("ip").value() ?: req.ip()  
              
            // lookupEngine.find won't use CommonPool  
            **val** info = lookupEngine.find(ip)  
            ...  
        }  
    } See the seamless transition when you invoke . Without exposing knowledge of using a different thread pool, I invoked a coroutine on a different context and will be getting results back without any shenanigans. Now this is possible due to both Kotlin’s syntax and coroutine implementation and shows how they go hand in hand to provide such a transparent context switching. This not only abstracts the knowledge away but takes away the coding cost that I might have to pay otherwise. Complete code of the server is . find(ip) available here Wrapping it up I think I will stop here. I would let you guys try it yourself and build your own opinion. One might say Scala already has the ! What is so exciting or different in Kotlin? I have honestly tried Scala many times, but was always overwhelmed by the syntax (I don’t know why, there are so many ways to do so many things). I really want to go to Scala town where I can mix-n-match functional, and object oriented style. But for now I am happy to see an emerging syntactically decent and clean coroutine implementation. Kotlin might be young but it’s surprisingly pleasant, stable, has an awesome community and bringing the always wanted support of coroutines to JVM. async/await support

Stories, News & Mentions about COMMONROOM

Commonroom’s Stories on HackerNoon