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

Proper Navigation in SwiftUI With Coordinators: A Guide

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

Stories, News & Mentions about COMMONROOM

Commonroom’s Stories on HackerNoon